def __init__(self, mln, db):
self.mln = mln.materialize(db)
self._evidence = []
# self.evidenceBackup = {}
self._variables = {}
self._variables_by_idx = {} # gnd atom idx -> variable
self._variables_by_gndatomidx = {} # gnd atom idx
self._gndatoms = {}
self._gndatoms_by_idx = {}
# get combined domain
self.domains = mergedom(self.mln.domains, db.domains)
# self.softEvidence = list(mln.posteriorProbReqs) # constraints on posterior
# probabilities are nothing but
# soft evidence and can be handled in exactly the same way
# ground members
self.formulas = list(self.mln.formulas)
# self.gndAtoms = {}
# self.gndBlockLookup = {}
# self.gndBlocks = {}
# self.gndAtomsByIdx = {}
# self.gndFormulas = []
# self.gndAtomOccurrencesInGFs = []
if isinstance(db, basestring):
db = Database.load(self.mln, dbfile=db)
elif isinstance(db, Database):
pass
elif db is None:
db = Database(self.mln)
else:
raise Exception("Not a valid database argument (type %s)" % (str(type(db))))
self.db = db
# materialize formula weights
self._materialize_weights()
return
def __init__(self, mln, db):
self.mln = mln.materialize(db)
self._evidence = []
# self.evidenceBackup = {}
self._variables = {}
self._variables_by_idx = {} # gnd atom idx -> variable
self._variables_by_gndatomidx = {} # gnd atom idx
self._gndatoms = {}
self._gndatoms_by_idx = {}
# get combined domain
self.domains = mergedom(self.mln.domains, db.domains)
# self.softEvidence = list(mln.posteriorProbReqs) # constraints on posterior
# probabilities are nothing but
# soft evidence and can be handled in exactly the same way
# ground members
self.formulas = list(self.mln.formulas)
# self.gndAtoms = {}
# self.gndBlockLookup = {}
# self.gndBlocks = {}
# self.gndAtomsByIdx = {}
# self.gndFormulas = []
# self.gndAtomOccurrencesInGFs = []
if isinstance(db, basestring):
db = Database.load(self.mln, dbfile=db)
elif isinstance(db, Database):
pass
elif db is None:
db = Database(self.mln)
else:
raise Exception("Not a valid database argument (type %s)" % (str(type(db))))
self.db = db
# materialize formula weights
self._materialize_weights()
return
def learn(self, databases, method=BPLL, **params):
'''
Triggers the learning parameter learning process for a given set of databases.
Returns a new MLN object with the learned parameters.
:param databases: list of :class:`mln.database.Database` objects or filenames
'''
verbose = params.get('verbose', False)
# get a list of database objects
if not databases:
raise Exception('At least one database is needed for learning.')
dbs = []
for db in databases:
if isinstance(db, basestring):
db = Database.load(self, db)
if type(db) is list: dbs.extend(db)
else: dbs.append(db)
elif type(db) is list: dbs.extend(db)
else: dbs.append(db)
logger.debug('loaded %s evidence databases for learning' % len(dbs))
newmln = self.materialize(*dbs)
logger.debug('MLN predicates:')
for p in newmln.predicates: logger.debug(p)
logger.debug('MLN domains:')
for d in newmln.domains.iteritems(): logger.debug(d)
if not newmln.formulas:
raise Exception('No formulas in the materialized MLN.')
logger.debug('MLN formulas:')
for f in newmln.formulas: logger.debug('%s %s' % (str(f.weight).ljust(10, ' '), f))
# run learner
if len(dbs) == 1:
mrf = newmln.ground(dbs[0])
logger.debug('Loading %s-Learner' % method.__name__)
learner = method(mrf, **params)
else:
learner = MultipleDatabaseLearner(newmln, dbs, method, **params)
if verbose:
"learner: %s" % learner.name
wt = learner.run(**params)
newmln.weights = wt
# fit prior prob. constraints if any available
if len(self.probreqs) > 0:
fittingParams = {
"fittingMethod": self.probabilityFittingInferenceMethod,
"fittingSteps": self.probabilityFittingMaxSteps,
"fittingThreshold": self.probabilityFittingThreshold
}
fittingParams.update(params)
print "fitting with params ", fittingParams
self._fitProbabilityConstraints(self.probreqs, **fittingParams)
if params.get('ignore_zero_weight_formulas', False):
formulas = list(newmln.formulas)
weights = list(newmln.weights)
fix = list(newmln.fixweights)
newmln._rmformulas()
for f, w,fi in zip(formulas, weights, fix):
if w != 0: newmln.formula(f, w, fi)
return newmln
def __get_db(self, request, config, mln):
if not request.query.evidence and config.db == "":
raise Exception("No evidence provided!")
if request.query.evidence and config.db != "":
raise Exception(
"Duplicate evidence; provide either a db in the config or an evidence db in the query"
)
if request.query.evidence:
to_return = parse_db(
mln, reduce(lambda x, y: x + "\n" + y, request.query.evidence))
else:
to_return = Database.load(mln, config.db)
if len(to_return) != 1:
raise Exception("Only one db is supported!")
return to_return[0]
def run(self):
'''
Run the MLN learning with the given parameters.
'''
# load the MLN
if isinstance(self.mln, MLN):
mln = self.mln
else:
raise Exception('No MLN specified')
# load the training databases
if type(self.db) is list and all(
[isinstance(e, Database) for e in self.db]):
dbs = self.db
elif isinstance(self.db, Database):
dbs = [self.db]
elif isinstance(self.db, str):
db = self.db
if db is None or not db:
raise Exception('no trainig data given!')
dbpaths = [os.path.join(self.directory, 'db', db)]
dbs = []
for p in dbpaths:
dbs.extend(Database.load(mln, p, self.ignore_unknown_preds))
else:
raise Exception(
'Unexpected type of training databases: %s' % type(self.db))
if self.verbose:
print(('loaded %d database(s).' % len(dbs)))
watch = StopWatch()
if self.verbose:
confg = dict(self._config)
confg.update(eval("dict(%s)" % self.params))
if type(confg.get('db', None)) is list:
confg['db'] = '%d Databases' % len(confg['db'])
print((tabulate(
sorted(list(confg.items()), key=lambda key_v: str(key_v[0])),
headers=('Parameter:', 'Value:'))))
params = dict([(k, getattr(self, k)) for k in (
'multicore', 'verbose', 'profile', 'ignore_zero_weight_formulas')])
# for discriminative learning
if issubclass(self.method, DiscriminativeLearner):
if self.discr_preds == QUERY_PREDS: # use query preds
params['qpreds'] = self.qpreds
elif self.discr_preds == EVIDENCE_PREDS: # use evidence preds
params['epreds'] = self.epreds
# gaussian prior settings
if self.use_prior:
params['prior_mean'] = self.prior_mean
params['prior_stdev'] = self.prior_stdev
# expand the parameters
params.update(self.params)
if self.profile:
prof = Profile()
print('starting profiler...')
prof.enable()
else:
prof = None
# set the debug level
olddebug = logger.level
logger.level = eval('logs.%s' % params.get('debug', 'WARNING').upper())
mlnlearnt = None
try:
# run the learner
mlnlearnt = mln.learn(dbs, self.method, **params)
if self.verbose:
print()
print(headline('LEARNT MARKOV LOGIC NETWORK'))
print()
mlnlearnt.write()
except SystemExit:
print('Cancelled...')
finally:
if self.profile:
prof.disable()
print(headline('PROFILER STATISTICS'))
ps = pstats.Stats(prof, stream=sys.stdout).sort_stats(
'cumulative')
ps.print_stats()
# reset the debug level
logger.level = olddebug
print()
watch.finish()
watch.printSteps()
return mlnlearnt
def learn(self, savegeometry=True, options=None, *_):
if options is None:
options = {}
mln_content = self.mln_container.editor.get("1.0", END).strip()
db_content = self.db_container.editor.get("1.0", END).strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print((headline('PRAC LEARNING TOOL')))
print()
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(mln_content, searchpaths=[self.project_dir],
projectpath=os.path.join(self.project_dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj, dbfiles=[options.get('dbarg')], ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
else:
if self.config.get('pattern'):
local, dblist = self.get_training_db_paths(self.config.get('pattern').strip())
dbobj = []
# build database list from project dbs
if local:
for dbname in dblist:
dbobj.extend(parse_db(mlnobj, self.project.dbs[dbname].strip(),
ignore_unknown_preds=self.config.get('ignore_unknown_preds', True),
projectpath=os.path.join(self.dir, self.project.name)))
out(dbobj)
# build database list from filesystem dbs
else:
for dbpath in dblist:
dbobj.extend(Database.load(mlnobj, dbpath, ignore_unknown_preds= self.config.get('ignore_unknown_preds', True)))
# build single db from currently selected db
else:
dbobj = parse_db(mlnobj, db_content, projectpath=os.path.join(self.dir, self.project.name), dirs=[self.dir])
learning = MLNLearn(config=self.config, mln=mlnobj, db=dbobj)
result = learning.run()
# write to file if run from commandline, otherwise save result
# to project results
if options.get('outputfile') is not None:
output = io.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')), 'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = io.StringIO()
result.write(output)
self.project.add_mln(self.output_filename.get(), output.getvalue())
self.mln_container.update_file_choices()
self.project.save(dirpath=self.project_dir)
logger.info('saved result to file mln/{} in project {}'.format(self.output_filename.get(), self.project.name))
else:
logger.debug("No output file given - results have not been saved.")
except:
traceback.print_exc()
# restore gui
sys.stdout.flush()
self.master.deiconify()
def infer(self, savegeometry=True, options={}, *args):
mln_content = self.mln_container.editor.get("1.0", END).strip()
db_content = self.db_container.editor.get("1.0", END).strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print((headline('PRACMLN QUERY TOOL')))
print()
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(
mln_content,
searchpaths=[self.dir],
projectpath=os.path.join(self.dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('emlnarg') is not None:
emln_content = mlnpath(options.get('emlnarg')).content
else:
emln_content = self.emln_container.editor.get("1.0",
END).strip()
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj,
dbfiles=[options.get('dbarg')],
ignore_unknown_preds=self.config.get(
'ignore_unknown_preds', True))
else:
out(self.config.get('ignore_unknown_preds', True))
dbobj = parse_db(mlnobj,
db_content,
ignore_unknown_preds=self.config.get(
'ignore_unknown_preds', True))
if options.get('queryarg') is not None:
self.config["queries"] = options.get('queryarg')
infer = MLNQuery(config=self.config,
mln=mlnobj,
db=dbobj,
emln=emln_content)
result = infer.run()
# write to file if run from commandline, otherwise save result to project results
if options.get('outputfile') is not None:
output = io.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')),
'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(
os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = io.StringIO()
result.write(output)
fname = self.output_filename.get()
self.project.add_result(fname, output.getvalue())
self.project.save(dirpath=self.dir)
logger.info(
'saved result to file results/{} in project {}'.format(
fname, self.project.name))
else:
logger.debug(
'No output file given - results have not been saved.')
except:
traceback.print_exc()
# restore main window
sys.stdout.flush()
self.master.deiconify()
def run(self):
'''
Run the MLN learning with the given parameters.
'''
# load the MLN
if isinstance(self.mln, MLN):
mln = self.mln
else:
raise Exception('No MLN specified')
# load the training databases
if type(self.db) is list and all(
map(lambda e: isinstance(e, Database), self.db)):
dbs = self.db
elif isinstance(self.db, Database):
dbs = [self.db]
elif isinstance(self.db, basestring):
db = self.db
if db is None or not db:
raise Exception('no trainig data given!')
dbpaths = [os.path.join(self.directory, 'db', db)]
dbs = []
for p in dbpaths:
dbs.extend(Database.load(mln, p, self.ignore_unknown_preds))
else:
raise Exception(
'Unexpected type of training databases: %s' % type(self.db))
if self.verbose:
print 'loaded %d database(s).' % len(dbs)
watch = StopWatch()
if self.verbose:
confg = dict(self._config)
confg.update(eval("dict(%s)" % self.params))
if type(confg.get('db', None)) is list:
confg['db'] = '%d Databases' % len(confg['db'])
print tabulate(
sorted(list(confg.viewitems()), key=lambda (key, v): str(key)),
headers=('Parameter:', 'Value:'))
params = dict([(k, getattr(self, k)) for k in (
'multicore', 'verbose', 'profile', 'ignore_zero_weight_formulas')])
# for discriminative learning
if issubclass(self.method, DiscriminativeLearner):
if self.discr_preds == QUERY_PREDS: # use query preds
params['qpreds'] = self.qpreds
elif self.discr_preds == EVIDENCE_PREDS: # use evidence preds
params['epreds'] = self.epreds
# gaussian prior settings
if self.use_prior:
params['prior_mean'] = self.prior_mean
params['prior_stdev'] = self.prior_stdev
# expand the parameters
params.update(self.params)
if self.profile:
prof = Profile()
print 'starting profiler...'
prof.enable()
else:
prof = None
# set the debug level
olddebug = praclog.level()
praclog.level(
eval('logging.%s' % params.get('debug', 'WARNING').upper()))
mlnlearnt = None
try:
# run the learner
mlnlearnt = mln.learn(dbs, self.method, **params)
if self.verbose:
print
print headline('LEARNT MARKOV LOGIC NETWORK')
print
mlnlearnt.write()
except SystemExit:
print 'Cancelled...'
finally:
if self.profile:
prof.disable()
print headline('PROFILER STATISTICS')
ps = pstats.Stats(prof, stream=sys.stdout).sort_stats(
'cumulative')
ps.print_stats()
# reset the debug level
praclog.level(olddebug)
print
watch.finish()
watch.printSteps()
return mlnlearnt
def learn(self, savegeometry=True, options={}, *args):
mln_content = self.mln_container.editor.get("1.0", END).encode('utf8').strip()
db_content = self.db_container.editor.get("1.0", END).encode('utf8').strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print headline('PRAC LEARNING TOOL')
print
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(mln_content, searchpaths=[self.project_dir],
projectpath=os.path.join(self.project_dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj, dbfiles=[options.get('dbarg')], ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
else:
if self.config.get('pattern'):
local, dblist = self.get_training_db_paths(self.config.get('pattern').strip())
dbobj = []
# build database list from project dbs
if local:
for dbname in dblist:
dbobj.extend(parse_db(mlnobj, self.project.dbs[dbname].strip(),
ignore_unknown_preds=self.config.get('ignore_unknown_preds', True),
projectpath=os.path.join(self.dir, self.project.name)))
out(dbobj)
# build database list from filesystem dbs
else:
for dbpath in dblist:
dbobj.extend(Database.load(mlnobj, dbpath, ignore_unknown_preds= self.config.get('ignore_unknown_preds', True)))
# build single db from currently selected db
else:
dbobj = parse_db(mlnobj, db_content, projectpath=os.path.join(self.dir, self.project.name), dirs=[self.dir])
learning = MLNLearn(config=self.config, mln=mlnobj, db=dbobj)
result = learning.run()
# write to file if run from commandline, otherwise save result
# to project results
if options.get('outputfile') is not None:
output = StringIO.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')), 'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = StringIO.StringIO()
result.write(output)
self.project.add_mln(self.output_filename.get(), output.getvalue())
self.mln_container.update_file_choices()
self.project.save(dirpath=self.project_dir)
logger.info('saved result to file mln/{} in project {}'.format(self.output_filename.get(), self.project.name))
else:
logger.debug("No output file given - results have not been saved.")
except:
traceback.print_exc()
# restore gui
sys.stdout.flush()
self.master.deiconify()
def infer(self, savegeometry=True, options={}, *args):
mln_content = self.mln_container.editor.get("1.0", END).encode('utf8').strip()
db_content = self.db_container.editor.get("1.0", END).encode('utf8').strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print headline('PRACMLN QUERY TOOL')
print
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(mln_content, searchpaths=[self.dir],
projectpath=os.path.join(self.dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('emlnarg') is not None:
emln_content = mlnpath(options.get('emlnarg')).content
else:
emln_content = self.emln_container.editor.get("1.0", END).encode('utf8').strip()
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj, dbfiles=[options.get('dbarg')], ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
else:
out(self.config.get('ignore_unknown_preds', True))
dbobj = parse_db(mlnobj, db_content, ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
if options.get('queryarg') is not None:
self.config["queries"] = options.get('queryarg')
infer = MLNQuery(config=self.config, mln=mlnobj, db=dbobj, emln=emln_content)
result = infer.run()
# write to file if run from commandline, otherwise save result to project results
if options.get('outputfile') is not None:
output = StringIO.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')), 'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = StringIO.StringIO()
result.write(output)
fname = self.output_filename.get()
self.project.add_result(fname, output.getvalue())
self.project.save(dirpath=self.dir)
logger.info('saved result to file results/{} in project {}'.format(fname, self.project.name))
else:
logger.debug('No output file given - results have not been saved.')
except:
traceback.print_exc()
# restore main window
sys.stdout.flush()
self.master.deiconify()
