def set_outputfilename(self):
if not hasattr(self, "output_filename") or not hasattr(
self, "db_filename") or not hasattr(self, "mln_filename"):
return
mln = self.mln_container.selected_file.get()
db = self.db_container.selected_file.get()
if "" in (mln, db):
return
if self.selected_method.get():
method = InferenceMethods.clazz(self.selected_method.get())
methodid = InferenceMethods.id(method)
filename = config.query_output_filename(mln, methodid, db)
self.output_filename.set(filename)
def update_config(self):
self.config = PRACMLNConfig()
self.config["use_emln"] = self.use_emln.get()
self.config['mln'] = self.mln_container.selected_file.get().strip(
).lstrip('*')
self.config['emln'] = self.emln_container.selected_file.get().strip(
).lstrip('*')
self.config["db"] = self.db_container.selected_file.get().strip(
).lstrip('*')
self.config["method"] = InferenceMethods.id(
self.selected_method.get().strip())
self.config["params"] = self.params.get().strip()
self.config["queries"] = self.query.get()
self.config["output_filename"] = self.output_filename.get().strip()
self.config["cw"] = self.closed_world.get()
self.config["cw_preds"] = self.cwPreds.get()
self.config['profile'] = self.profile.get()
self.config['logic'] = self.selected_logic.get()
self.config['grammar'] = self.selected_grammar.get()
self.config['multicore'] = self.multicore.get()
self.config['save'] = self.save.get()
self.config['ignore_unknown_preds'] = self.ignore_unknown_preds.get()
self.config['verbose'] = self.verbose.get()
self.config['window_loc'] = self.master.winfo_geometry()
self.config['dir'] = self.dir
self.project.queryconf = PRACMLNConfig()
self.project.queryconf.update(self.config.config.copy())
def set_config(self, newconf):
self.config = newconf
self.selected_grammar.set(ifnone(newconf.get('grammar'),
'PRACGrammar'))
self.selected_logic.set(ifnone(newconf.get('logic'),
'FirstOrderLogic'))
self.mln_container.selected_file.set(ifnone(newconf.get('mln'), ''))
if self.use_emln.get():
self.emln_container.selected_file.set(
ifnone(newconf.get('mln'), ''))
self.db_container.selected_file.set(ifnone(newconf.get('db'), ""))
self.selected_method.set(
ifnone(newconf.get("method"),
InferenceMethods.name('MCSAT'),
transform=InferenceMethods.name))
self.multicore.set(ifnone(newconf.get('multicore'), 0))
self.profile.set(ifnone(newconf.get('profile'), 0))
self.params.set(ifnone(newconf.get('params'), ''))
self.use_emln.set(ifnone(newconf.get('use_emln'), 0))
self.verbose.set(ifnone(newconf.get('verbose'), 1))
self.ignore_unknown_preds.set(
ifnone(newconf.get('ignore_unknown_preds'), 0))
self.output_filename.set(ifnone(newconf.get('output_filename'), ''))
self.cwPreds.set(ifnone(newconf.get('cw_preds'), ''))
self.closed_world.set(ifnone(newconf.get('cw'), 0))
self.save.set(ifnone(newconf.get('save'), 0))
self.query.set(ifnone(newconf.get('queries'), ''))
self.onchange_cw()
def __handle_mln_query(self, request):
try:
rospy.loginfo("Processing request...")
config = self.__get_config(request)
if self.__config_changed(config):
rospy.loginfo("Configuration changed")
self.__mln = MLN(config.logic, config.grammar, config.mlnFiles)
self.__mln_date = os.path.getmtime(config.mlnFiles)
self.__config = config
db = self.__get_db(request, config, self.__mln)
materialized_mln = self.__mln.materialize(db)
mrf = materialized_mln.ground(db)
if not request.query:
raise Exception("No query provided!")
inference = InferenceMethods.clazz(config.method)(
mrf, request.query.queries)
result = inference.run()
self.__save_results(config, result)
tuple_list = []
for atom, probability in inference.results.items():
tuple_list.append(AtomProbPair(str(atom), float(probability)))
tuple_list.sort(key=lambda item: item.prob, reverse=True)
to_return = MLNInterfaceResponse(MLNDatabase(tuple_list))
rospy.loginfo("Done!")
return to_return
except Exception:
rospy.logfatal(traceback.format_exc())
return MLNDatabase([])
def set_config(self, conf):
self.config = conf
self.selected_logic.set(ifnone(conf.get('logic'), 'FirstOrderLogic'))
self.mln_container.selected_file.set(ifnone(conf.get('mln'), ''))
if not self.keep_evidence:
self.db_container.selected_file.set(ifnone(conf.get('db'), ''))
self.selected_method.set(
ifnone(self.config.get("method"),
InferenceMethods.name('MCSAT'),
transform=InferenceMethods.name))
self.use_emln.set(ifnone(conf.get('use_emln'), False))
if self.use_emln.get():
self.emln_container.selected_file.set(ifnone(conf.get('emln'), ""))
self.multicore.set(ifnone(conf.get('multicore'), False))
self.verbose.set(ifnone(conf.get('verbose'), False))
self.params.set(ifnone(conf.get('params'), ''))
self.cwpreds.set(ifnone(conf.get('cw_preds'), ''))
self.closed_world.set(ifnone(conf.get('cw'), False))
self.query.set(ifnone(conf.get('queries'), 'foo, bar'))
def __init__(self, master, gconf, directory=None):
self.master = master
self.initialized = False
self.master.bind('<Return>', self.infer)
self.master.bind('<Escape>', lambda a: self.master.quit())
self.master.protocol('WM_DELETE_WINDOW', self.quit)
self.dir = os.path.abspath(
ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
self.frame = Frame(master)
self.frame.pack(fill=BOTH, expand=1)
self.frame.columnconfigure(1, weight=1)
row = 0
# pracmln project options
Label(self.frame, text='PRACMLN Project: ').grid(row=row,
column=0,
sticky='ES')
project_container = Frame(self.frame)
project_container.grid(row=row, column=1, sticky="NEWS")
# new proj file
self.btn_newproj = Button(project_container,
text='New Project...',
command=self.new_project)
self.btn_newproj.grid(row=0, column=1, sticky="WS")
# open proj file
self.btn_openproj = Button(project_container,
text='Open Project...',
command=self.ask_load_project)
self.btn_openproj.grid(row=0, column=2, sticky="WS")
# save proj file
self.btn_updateproj = Button(project_container,
text='Save Project...',
command=self.noask_save_project)
self.btn_updateproj.grid(row=0, column=3, sticky="WS")
# save proj file as...
self.btn_saveproj = Button(project_container,
text='Save Project as...',
command=self.ask_save_project)
self.btn_saveproj.grid(row=0, column=4, sticky="WS")
# grammar selection
row += 1
Label(self.frame, text='Grammar: ').grid(row=row, column=0, sticky='E')
grammars = ['StandardGrammar', 'PRACGrammar']
self.selected_grammar = StringVar()
self.selected_grammar.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_grammar) + tuple(grammars))
l.grid(row=row, column=1, sticky='NWE')
# logic selection
row += 1
Label(self.frame, text='Logic: ').grid(row=row, column=0, sticky='E')
logics = ['FirstOrderLogic', 'FuzzyLogic']
self.selected_logic = StringVar()
self.selected_logic.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_logic) + tuple(logics))
l.grid(row=row, column=1, sticky='NWE')
# mln section
row += 1
Label(self.frame, text="MLN: ").grid(row=row, column=0, sticky='NE')
self.mln_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={
'extension': '.mln',
'ftypes': [('MLN files', '.mln')]
},
defaultname='*unknown{}',
importhook=self.import_mln,
deletehook=self.delete_mln,
projecthook=self.save_proj,
filecontenthook=self.mlnfilecontent,
fileslisthook=self.mlnfiles,
updatehook=self.update_mln,
onchangehook=self.project_setdirty)
self.mln_container.editor.bind("<FocusIn>", self._got_focus)
self.mln_container.grid(row=row, column=1, sticky="NEWS")
self.mln_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
row += 1
self.use_emln = IntVar()
self.use_emln.set(0)
self.cb_use_emln = Checkbutton(self.frame,
text="use model extension",
variable=self.use_emln,
command=self.onchange_use_emln)
self.cb_use_emln.grid(row=row, column=1, sticky="W")
# mln extension section
row += 1
self.emlncontainerrow = row
self.emln_label = Label(self.frame, text="EMLN: ")
self.emln_label.grid(row=self.emlncontainerrow, column=0, sticky='NE')
self.emln_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={
'extension':
'.emln',
'ftypes':
[('MLN extension files', '.emln')
]
},
defaultname='*unknown{}',
importhook=self.import_emln,
deletehook=self.delete_emln,
projecthook=self.save_proj,
filecontenthook=self.emlnfilecontent,
fileslisthook=self.emlnfiles,
updatehook=self.update_emln,
onchangehook=self.project_setdirty)
self.emln_container.grid(row=self.emlncontainerrow,
column=1,
sticky="NEWS")
self.emln_container.editor.bind("<FocusIn>", self._got_focus)
self.emln_container.columnconfigure(1, weight=2)
self.onchange_use_emln(dirty=False)
self.frame.rowconfigure(row, weight=1)
# db section
row += 1
Label(self.frame, text="Evidence: ").grid(row=row,
column=0,
sticky='NE')
self.db_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={
'extension': '.db',
'ftypes':
[('Database files', '.db')]
},
defaultname='*unknown{}',
importhook=self.import_db,
deletehook=self.delete_db,
projecthook=self.save_proj,
filecontenthook=self.dbfilecontent,
fileslisthook=self.dbfiles,
updatehook=self.update_db,
onchangehook=self.project_setdirty)
self.db_container.grid(row=row, column=1, sticky="NEWS")
self.db_container.editor.bind("<FocusIn>", self._got_focus)
self.db_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
# inference method selection
row += 1
self.list_methods_row = row
Label(self.frame, text="Method: ").grid(row=row, column=0, sticky=E)
self.selected_method = StringVar()
self.selected_method.trace('w', self.select_method)
methodnames = sorted(InferenceMethods.names())
self.list_methods = OptionMenu(*(self.frame, self.selected_method) +
tuple(methodnames))
self.list_methods.grid(row=self.list_methods_row,
column=1,
sticky="NWE")
# options
row += 1
option_container = Frame(self.frame)
option_container.grid(row=row, column=1, sticky="NEWS")
# Multiprocessing
self.multicore = IntVar()
self.cb_multicore = Checkbutton(option_container,
text="Use all CPUs",
variable=self.multicore,
command=self.settings_setdirty)
self.cb_multicore.grid(row=0, column=2, sticky=W)
# profiling
self.profile = IntVar()
self.cb_profile = Checkbutton(option_container,
text='Use Profiler',
variable=self.profile,
command=self.settings_setdirty)
self.cb_profile.grid(row=0, column=3, sticky=W)
# verbose
self.verbose = IntVar()
self.cb_verbose = Checkbutton(option_container,
text='verbose',
variable=self.verbose,
command=self.settings_setdirty)
self.cb_verbose.grid(row=0, column=4, sticky=W)
# options
self.ignore_unknown_preds = IntVar()
self.cb_ignore_unknown_preds = Checkbutton(
option_container,
text='ignore unkown predicates',
variable=self.ignore_unknown_preds,
command=self.settings_setdirty)
self.cb_ignore_unknown_preds.grid(row=0, column=5, sticky="W")
# queries
row += 1
Label(self.frame, text="Queries: ").grid(row=row, column=0, sticky=E)
self.query = StringVar()
self.query.trace('w', self.settings_setdirty)
Entry(self.frame, textvariable=self.query).grid(row=row,
column=1,
sticky="NEW")
# additional parameters
row += 1
Label(self.frame, text="Add. params: ").grid(row=row,
column=0,
sticky="NE")
self.params = StringVar()
self.params.trace('w', self.settings_setdirty)
self.entry_params = Entry(self.frame, textvariable=self.params)
self.entry_params.grid(row=row, column=1, sticky="NEW")
# closed-world predicates
row += 1
Label(self.frame, text="CW preds: ").grid(row=row,
column=0,
sticky="E")
cw_container = Frame(self.frame)
cw_container.grid(row=row, column=1, sticky='NEWS')
cw_container.columnconfigure(0, weight=1)
self.cwPreds = StringVar()
self.cwPreds.trace('w', self.settings_setdirty)
self.entry_cw = Entry(cw_container, textvariable=self.cwPreds)
self.entry_cw.grid(row=0, column=0, sticky="NEWS")
self.closed_world = IntVar()
self.cb_closed_world = Checkbutton(cw_container,
text="CW Assumption",
variable=self.closed_world,
command=self.onchange_cw)
self.cb_closed_world.grid(row=0, column=1, sticky='W')
# output filename
row += 1
output_cont = Frame(self.frame)
output_cont.grid(row=row, column=1, sticky='NEWS')
output_cont.columnconfigure(0, weight=1)
# - filename
Label(self.frame, text="Output: ").grid(row=row, column=0, sticky="NE")
self.output_filename = StringVar()
self.entry_output_filename = Entry(output_cont,
textvariable=self.output_filename)
self.entry_output_filename.grid(row=0, column=0, sticky="NEW")
# - save option
self.save = IntVar()
self.cb_save = Checkbutton(output_cont,
text="save",
variable=self.save)
self.cb_save.grid(row=0, column=1, sticky=W)
# start button
row += 1
start_button = Button(self.frame,
text=">> Start Inference <<",
command=self.infer)
start_button.grid(row=row, column=1, sticky="NEW")
self.settings_dirty = IntVar()
self.project_dirty = IntVar()
self.gconf = gconf
self.project = None
self.project_dir = os.path.abspath(
ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
if gconf['prev_query_project':self.project_dir] is not None:
self.load_project(
os.path.join(self.project_dir,
gconf['prev_query_project':self.project_dir]))
else:
self.new_project()
self.config = self.project.queryconf
self.project.addlistener(self.project_setdirty)
self.mln_container.dirty = False
self.emln_container.dirty = False
self.db_container.dirty = False
self.project_setdirty(dirty=False)
self.master.geometry(gconf['window_loc_query'])
self.initialized = True
def method(self):
return InferenceMethods.clazz(self._config.get('method', 'MC-SAT'))
def apply_prob_constraints(self, constraints, method=InferenceMethods.EnumerationAsk,
thr=1.0e-3, steps=20, fittingMCSATSteps=5000,
fittingParams=None, given=None, queries=None,
maxThreshold=None, greedy=False, probabilityFittingResultFileName=None, **args):
'''
Applies the given probability constraints (if any), dynamically
modifying weights of the underlying MLN by applying iterative proportional fitting
:param constraints: list of constraints
:param method: one of the inference methods defined in InferenceMethods
inferenceParams: parameters to pass on to the inference method
:param given: if not None, fit parameters of posterior (given the evidence) rather than prior
:param querie queries to compute along the way, results for which will be returned
:param thr: when maximum absolute difference between desired and actual probability drops below this value, then stop (convergence)
maxThreshold:
if not None, then convergence is relaxed, and we stop when the *mean* absolute difference between desired and
actual probability drops below "threshold" *and* the maximum is below "maxThreshold"
'''
if fittingParams is None:
fittingParams = {}
inferenceParams = fittingParams
inferenceParams["doProbabilityFitting"] = False # avoid recursive fitting calls when calling embedded inference method
if given == None:
given = ""
if queries is None:
queries = []
if inferenceParams is None:
inferenceParams = {}
if not constraints:
if queries: pass # TODO !!!! because this is called from inferIPFPM, should perform inference anyhow
return
t_start = time.time()
# determine relevant formulas
for req in constraints:
# if we don't yet have a ground formula to fit, create one
if not "gndFormula" in req:
# if we don't yet have a formula to use, search for one that matches the expression to fit
if not "idxFormula" in req:
idxFormula = None
for idxF, formula in enumerate(self.formulas):
#print strFormula(formula), req["expr"]
if fstr(formula).replace(" ", "") == req["expr"]:
idxFormula = idxF
break
if idxFormula is None:
raise Exception("Probability constraint on '%s' cannot be applied because the formula is not part of the MLN!" % req["expr"])
req["idxFormula"] = idxFormula
# instantiate a ground formula
formula = self.formulas[req["idxFormula"]]
variables = formula.getVariables(self)
groundVars = {}
for varName, domName in variables.iteritems(): # instantiate vars arbitrarily (just use first element of domain)
groundVars[varName] = self.domains[domName][0]
gndFormula = formula.ground(self, groundVars)
req["gndExpr"] = str(gndFormula)
req["gndFormula"] = gndFormula
# iterative fitting algorithm
step = 1 # fitting round
fittingStep = 1 # actual IPFP iteration
#print "probConstraints", probConstraints, "queries", queries
what = [r["gndFormula"] for r in constraints] + queries
done = False
while step <= steps and not done:
# calculate probabilities of the constrained formulas (ground formula)
if method is InferenceMethods.Exact:
if not hasattr(self, "worlds"):
self._getWorlds()
else:
self._calculateWorldValues()
results = self.inferExact(what, given=given, verbose=False, **inferenceParams)
elif method == InferenceMethods.EnumerationAsk:
results = self.inferEnumerationAsk(what, given=given, verbose=False, **inferenceParams)
#elif inferenceMethod == InferenceMethods.ExactLazy:
# results = self.inferExactLazy(what, given=given, verbose=False, **inferenceParams)
elif method == InferenceMethods.MCSAT:
results = self.inferMCSAT(what, given=given, verbose=False, maxSteps = fittingMCSATSteps, **inferenceParams)
else:
raise Exception("Requested inference method (%s) not supported by probability constraint fitting" % InferenceMethods.getName(method))
if type(results) != list:
results = [results]
# compute deviations
diffs = [abs(r["p"] - results[i]) for (i, r) in enumerate(constraints)]
maxdiff = max(diffs)
meandiff = sum(diffs) / len(diffs)
# are we done?
done = maxdiff <= thr
if not done and maxThreshold is not None: # relaxed convergence criterion
done = (meandiff <= thr) and (maxdiff <= maxThreshold)
if done: break
# select constraint to fit
if greedy:
idxConstraint = diffs.index(maxdiff)
strStep = "%d;%d" % (step, fittingStep)
else:
idxConstraint = (fittingStep - 1) % len(constraints)
strStep = "%d;%d/%d" % (step, idxConstraint + 1, len(constraints))
req = constraints[idxConstraint]
# get the scaling factor and apply it
formula = self.formulas[req["idxFormula"]]
p = results[idxConstraint]
#print "p", p, "results", results, "idxConstraint", idxConstraint
pnew = req["p"]
precision = 1e-3
if p == 0.0: p = precision
if p == 1.0: p = 1 - precision
f = pnew * (1 - p) / p / (1 - pnew)
old_weight = formula.weight
formula.weight += float(logx(f)) #make sure to set the weight to a native float and not an mpmath value
diff = diffs[idxConstraint]
# print status
logger.debug(" [%s] p=%f vs. %f (diff = %f), weight %s: %f -> %f, dev max %f mean %f, elapsed: %.3fs" % (strStep, p, pnew, diff, str(formula), old_weight, formula.weight, maxdiff, meandiff, time.time() - t_start))
if fittingStep % len(constraints) == 0:
step += 1
fittingStep += 1
#write resulting mln:
if probabilityFittingResultFileName != None:
mlnFile = file(probabilityFittingResultFileName, "w")
self.mln.write(mlnFile)
mlnFile.close()
print "written MLN with probability constraints to:", probabilityFittingResultFileName
return (results[len(constraints):], {"steps": min(step, steps), "fittingSteps": fittingStep, "maxdiff": maxdiff, "meandiff": meandiff, "time": time.time() - t_start})
def apply_prob_constraints(self, constraints, method=InferenceMethods.EnumerationAsk,
thr=1.0e-3, steps=20, fittingMCSATSteps=5000,
fittingParams=None, given=None, queries=None,
maxThreshold=None, greedy=False, probabilityFittingResultFileName=None, **args):
'''
Applies the given probability constraints (if any), dynamically
modifying weights of the underlying MLN by applying iterative proportional fitting
:param constraints: list of constraints
:param method: one of the inference methods defined in InferenceMethods
inferenceParams: parameters to pass on to the inference method
:param given: if not None, fit parameters of posterior (given the evidence) rather than prior
:param querie queries to compute along the way, results for which will be returned
:param thr: when maximum absolute difference between desired and actual probability drops below this value, then stop (convergence)
maxThreshold:
if not None, then convergence is relaxed, and we stop when the *mean* absolute difference between desired and
actual probability drops below "threshold" *and* the maximum is below "maxThreshold"
'''
if fittingParams is None:
fittingParams = {}
inferenceParams = fittingParams
inferenceParams["doProbabilityFitting"] = False # avoid recursive fitting calls when calling embedded inference method
if given == None:
given = ""
if queries is None:
queries = []
if inferenceParams is None:
inferenceParams = {}
if not constraints:
if queries: pass # TODO !!!! because this is called from inferIPFPM, should perform inference anyhow
return
t_start = time.time()
# determine relevant formulas
for req in constraints:
# if we don't yet have a ground formula to fit, create one
if not "gndFormula" in req:
# if we don't yet have a formula to use, search for one that matches the expression to fit
if not "idxFormula" in req:
idxFormula = None
for idxF, formula in enumerate(self.formulas):
#print strFormula(formula), req["expr"]
if fstr(formula).replace(" ", "") == req["expr"]:
idxFormula = idxF
break
if idxFormula is None:
raise Exception("Probability constraint on '%s' cannot be applied because the formula is not part of the MLN!" % req["expr"])
req["idxFormula"] = idxFormula
# instantiate a ground formula
formula = self.formulas[req["idxFormula"]]
variables = formula.getVariables(self)
groundVars = {}
for varName, domName in variables.iteritems(): # instantiate vars arbitrarily (just use first element of domain)
groundVars[varName] = self.domains[domName][0]
gndFormula = formula.ground(self, groundVars)
req["gndExpr"] = str(gndFormula)
req["gndFormula"] = gndFormula
# iterative fitting algorithm
step = 1 # fitting round
fittingStep = 1 # actual IPFP iteration
#print "probConstraints", probConstraints, "queries", queries
what = [r["gndFormula"] for r in constraints] + queries
done = False
while step <= steps and not done:
# calculate probabilities of the constrained formulas (ground formula)
if method is InferenceMethods.Exact:
if not hasattr(self, "worlds"):
self._getWorlds()
else:
self._calculateWorldValues()
results = self.inferExact(what, given=given, verbose=False, **inferenceParams)
elif method == InferenceMethods.EnumerationAsk:
results = self.inferEnumerationAsk(what, given=given, verbose=False, **inferenceParams)
#elif inferenceMethod == InferenceMethods.ExactLazy:
# results = self.inferExactLazy(what, given=given, verbose=False, **inferenceParams)
elif method == InferenceMethods.MCSAT:
results = self.inferMCSAT(what, given=given, verbose=False, maxSteps = fittingMCSATSteps, **inferenceParams)
else:
raise Exception("Requested inference method (%s) not supported by probability constraint fitting" % InferenceMethods.getName(method))
if type(results) != list:
results = [results]
# compute deviations
diffs = [abs(r["p"] - results[i]) for (i, r) in enumerate(constraints)]
maxdiff = max(diffs)
meandiff = sum(diffs) / len(diffs)
# are we done?
done = maxdiff <= thr
if not done and maxThreshold is not None: # relaxed convergence criterion
done = (meandiff <= thr) and (maxdiff <= maxThreshold)
if done: break
# select constraint to fit
if greedy:
idxConstraint = diffs.index(maxdiff)
strStep = "%d;%d" % (step, fittingStep)
else:
idxConstraint = (fittingStep - 1) % len(constraints)
strStep = "%d;%d/%d" % (step, idxConstraint + 1, len(constraints))
req = constraints[idxConstraint]
# get the scaling factor and apply it
formula = self.formulas[req["idxFormula"]]
p = results[idxConstraint]
#print "p", p, "results", results, "idxConstraint", idxConstraint
pnew = req["p"]
precision = 1e-3
if p == 0.0: p = precision
if p == 1.0: p = 1 - precision
f = pnew * (1 - p) / p / (1 - pnew)
old_weight = formula.weight
formula.weight += float(logx(f)) #make sure to set the weight to a native float and not an mpmath value
diff = diffs[idxConstraint]
# print status
logger.debug(" [%s] p=%f vs. %f (diff = %f), weight %s: %f -> %f, dev max %f mean %f, elapsed: %.3fs" % (strStep, p, pnew, diff, str(formula), old_weight, formula.weight, maxdiff, meandiff, time.time() - t_start))
if fittingStep % len(constraints) == 0:
step += 1
fittingStep += 1
#write resulting mln:
if probabilityFittingResultFileName != None:
mlnFile = file(probabilityFittingResultFileName, "w")
self.mln.write(mlnFile)
mlnFile.close()
print "written MLN with probability constraints to:", probabilityFittingResultFileName
return (results[len(constraints):], {"steps": min(step, steps), "fittingSteps": fittingStep, "maxdiff": maxdiff, "meandiff": meandiff, "time": time.time() - t_start})
def __init__(self, master, prac, node, gconf, directory='.'):
self.logger = logs.getlogger(self.__class__.__name__, level=logs.DEBUG)
self.master = master
self.initialized = False
self.master.bind('<Return>', self.start)
self.master.bind('<Escape>', lambda a: self.master.quit())
self.master.protocol('WM_DELETE_WINDOW', self.quit)
self.prac = prac
self.prac_inference = node.pracinfer
self.infStep = None
self.module_dir = os.path.join(locations.pracmodules, 'wnsenses')
self.frame = Frame(master)
self.frame.pack(fill=BOTH, expand=1)
self.frame.columnconfigure(1, weight=1)
# module selection
row = 0
Label(self.frame, text="Module: ").grid(row=row, column=0, sticky="E")
modules = sorted([module for module in self.prac._manifests_by_name])
self.selected_module = StringVar(master)
self.selected_module.trace("w", self.select_module)
self.list_modules = OptionMenu(*(self.frame, self.selected_module) +
tuple(modules))
self.list_modules.grid(row=row, column=1, sticky="NWE")
# Project selection
row += 1
Label(self.frame, text="Project: ").grid(row=row, column=0, sticky="E")
saveprojectcontainer = Frame(self.frame)
saveprojectcontainer.grid(row=row, column=1, sticky="NEWS")
saveprojectcontainer.columnconfigure(0, weight=1)
self.selected_project = StringVar(master)
projectfiles = ['']
self.list_projects = OptionMenu(
*(saveprojectcontainer, self.selected_project) +
tuple(projectfiles))
self.list_projects.grid(row=0, column=0, sticky="NWES")
self.selected_project.trace("w", self.select_project)
# save proj file
self.btn_saveproj = Button(saveprojectcontainer,
text='Save Project...',
command=self.noask_save_project)
self.btn_saveproj.grid(row=0, column=1, sticky="E")
# save proj file as...
self.btn_saveproj = Button(saveprojectcontainer,
text='Save Project as...',
command=self.ask_save_project)
self.btn_saveproj.grid(row=0, column=2, sticky="E")
# logic selection
row += 1
Label(self.frame, text='Logic: ').grid(row=row, column=0, sticky='E')
logics = ['FirstOrderLogic', 'FuzzyLogic']
self.selected_logic = StringVar(master)
self.selected_logic.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_logic) + tuple(logics))
l.grid(row=row, column=1, sticky='NWE')
# mln section
row += 1
Label(self.frame, text="MLN: ").grid(row=row, column=0, sticky='NE')
self.mln_container = FileEditBar(self.frame,
dir=self.module_dir,
filesettings={
'extension': '.mln',
'ftypes': [('MLN files', '.mln')]
},
defaultname='*unknown{}',
importhook=self.import_mln,
deletehook=self.delete_mln,
projecthook=self.save_proj,
filecontenthook=self.mlnfilecontent,
fileslisthook=self.mlnfiles,
updatehook=self.update_mln,
onchangehook=self.project_setdirty)
self.mln_container.grid(row=row, column=1, sticky="NEWS")
self.mln_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
row += 1
self.use_emln = IntVar()
self.use_emln.set(0)
self.cb_use_emln = Checkbutton(self.frame,
text="use model extension",
variable=self.use_emln,
command=self.onchange_use_emln)
self.cb_use_emln.grid(row=row, column=1, sticky="W")
# mln extension section
row += 1
self.emlncontainerrow = row
self.emln_label = Label(self.frame, text="EMLN: ")
self.emln_label.grid(row=self.emlncontainerrow, column=0, sticky='NE')
self.emln_container = FileEditBar(self.frame,
dir=self.module_dir,
filesettings={
'extension':
'.emln',
'ftypes':
[('MLN extension files', '.emln')
]
},
defaultname='*unknown{}',
importhook=self.import_emln,
deletehook=self.delete_emln,
projecthook=self.save_proj,
filecontenthook=self.emlnfilecontent,
fileslisthook=self.emlnfiles,
updatehook=self.update_emln,
onchangehook=self.project_setdirty)
self.emln_container.grid(row=self.emlncontainerrow,
column=1,
sticky="NEWS")
self.emln_container.columnconfigure(1, weight=2)
self.onchange_use_emln(dirty=False)
self.frame.rowconfigure(row, weight=1)
# db section
row += 1
Label(self.frame, text="Evidence: ").grid(row=row,
column=0,
sticky='NE')
self.db_container = FileEditBar(self.frame,
dir=self.module_dir,
filesettings={
'extension': '.db',
'ftypes':
[('Database files', '.db')]
},
defaultname='*unknown{}',
importhook=self.import_db,
deletehook=self.delete_db,
projecthook=self.save_proj,
filecontenthook=self.dbfilecontent,
fileslisthook=self.dbfiles,
updatehook=self.update_db,
onchangehook=self.project_setdirty)
self.db_container.grid(row=row, column=1, sticky="NEWS")
self.db_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
# inference method selection
row += 1
self.list_methods_row = row
Label(self.frame, text="Method: ").grid(row=row, column=0, sticky=E)
self.selected_method = StringVar(master)
self.selected_method.trace('w', self.settings_setdirty)
self.list_methods = OptionMenu(self.frame, self.selected_method,
*InferenceMethods.names())
self.list_methods.grid(row=self.list_methods_row,
column=1,
sticky="NWE")
# queries
row += 1
Label(self.frame, text="Queries: ").grid(row=row, column=0, sticky=E)
self.query = StringVar(master)
Entry(self.frame, textvariable=self.query).grid(row=row,
column=1,
sticky="NEW")
# parameters
row += 1
Label(self.frame, text="Parameters: ").grid(row=row,
column=0,
sticky="NE")
self.params = StringVar(master)
self.entry_params = Entry(self.frame, textvariable=self.params)
self.entry_params.grid(row=row, column=1, sticky="NEW")
# closed-world predicates
row += 1
Label(self.frame, text="CW preds: ").grid(row=row,
column=0,
sticky="NE")
self.cwpreds = StringVar(master)
self.entry_cw = Entry(self.frame, textvariable=self.cwpreds)
self.entry_cw.grid(row=row, column=1, sticky="NEW")
# all preds open-world
cw_container = Frame(self.frame)
cw_container.grid(row=row, column=1, sticky="NES")
self.closed_world = IntVar()
self.cb_closed_world = Checkbutton(
cw_container,
text="Apply CW assumption to all except queries",
variable=self.closed_world)
self.cb_closed_world.grid(row=row, column=2, sticky='E')
# Multiprocessing and verbose
row += 1
options_container = Frame(self.frame)
options_container.grid(row=row, column=1, sticky='NEWS')
self.multicore = IntVar()
self.cb_multicore = Checkbutton(options_container,
text="Use all CPUs",
variable=self.multicore)
self.cb_multicore.grid(row=0, column=0, sticky=W)
self.verbose = IntVar()
self.cb_verbose = Checkbutton(options_container,
text="verbose",
variable=self.verbose)
self.cb_verbose.grid(row=0, column=1, sticky=W)
self.keep_evidence = IntVar()
self.cb_keep_evidence = Checkbutton(options_container,
text="keep result",
variable=self.keep_evidence)
self.cb_keep_evidence.grid(row=0, column=2, sticky=W)
self.keep_evidence.set(True)
# start and continue buttons
row += 1
self.btn_container = Frame(self.frame)
self.btn_container.grid(row=row, column=1, sticky='EW')
start_button = Button(self.btn_container,
text="Start Inference",
command=self.start)
start_button.grid(row=0, column=1, sticky='E')
continue_button = Button(self.btn_container,
text="Continue >",
command=self.oncontinue)
continue_button.grid(row=0, column=2, sticky='W')
self.settings_dirty = IntVar()
self.project_dirty = IntVar()
self.gconf = gconf
self.project = None
self.dir = os.path.abspath(
ifnone(gconf['prev_query_path'], DEFAULT_CONFIG))
if gconf['prev_query_project':self.dir] is not None:
self.load_project(
os.path.join(self.dir, gconf['prev_query_project':self.dir]))
else:
self.new_project()
self.config = self.project.queryconf
self.project.addlistener(self.project_setdirty)
self.selected_module.set(self.gconf.get("module", modules[0]))
self.update_dbeditor_from_result(node.outdbs)
self.mln_container.dirty = False
self.emln_container.dirty = False
self.db_container.dirty = False
self.project_setdirty(dirty=False)
self.master.geometry(gconf['window_loc_query'])
self.initialized = True