def __init__(self, mln_, dbs, method, **params): ''' :param dbs: list of :class:`mln.database.Database` objects to be used for learning. :param mln_: the MLN object to be used for learning :param method: the algorithm to be used for learning. Must be a class provided by :class:`mln.methods.LearningMethods`. :param **params: additional parameters handed over to the base learners. ''' self.dbs = dbs self._params = edict(params) if not mln_._materialized: self.mln = mln_.materialize(*dbs) else: self.mln = mln_ self.watch = StopWatch() self.learners = [None] * len(dbs) self.watch.tag('setup learners', verbose=self.verbose) if self.verbose: bar = ProgressBar(steps=len(dbs), color='green') if self.multicore: pool = Pool(maxtasksperchild=1) logger.debug( 'Setting up multi-core processing for {} cores'.format( pool._processes)) try: for i, learner in pool.imap(with_tracing(_setup_learner), self._iterdbs(method)): self.learners[i] = learner if self.verbose: bar.label('Database %d, %s' % ((i + 1), learner.name)) bar.inc() except Exception as e: logger.error('Error in child process. Terminating pool...') pool.close() raise e finally: pool.terminate() pool.join() # as MLNs and formulas have been copied to the separate processes, # the mln pointers of the formulas now point to the MLNs in these child processes # we have to copy the materialized weight back to our parent process self.mln.weights = list(first(self.learners).mrf.mln.weights) else: for i, db in enumerate(self.dbs): _, learner = _setup_learner( (i, self.mln, db, method, self._params + { 'multicore': False })) self.learners[i] = learner if self.verbose: bar.label('Database %d, %s' % ((i + 1), learner.name)) bar.inc() if self.verbose: print 'set up', self.name self.watch.finish('setup learners')
def __init__(self, mrf, queries=ALL, **params): self.mrf = mrf self.mln = mrf.mln self._params = edict(params) if not queries: self.queries = [ self.mln.logic.gnd_lit(ga, negated=False, mln=self.mln) for ga in self.mrf.gndatoms if self.mrf.evidence[ga.idx] is None ] else: # check for single/multiple query and expand if type(queries) is not list: queries = [queries] self.queries = self._expand_queries(queries) # fill in the missing truth values of variables that have only one remaining value for variable in self.mrf.variables: if variable.valuecount(self.mrf.evidence_dicti( )) == 1: # the var is fully determined by the evidence for _, value in variable.itervalues(self.mrf.evidence): break self.mrf.set_evidence(variable.value2dict(value), erase=False) # apply the closed world assumptions to the explicitly specified predicates if self.cwpreds: for pred in self.cwpreds: if isinstance(self.mln.predicate(pred), SoftFunctionalPredicate): if self.verbose: logger.warning( 'Closed world assumption will be applied to soft functional predicate %s' % pred) elif isinstance(self.mln.predicate(pred), FunctionalPredicate): raise Exception( 'Closed world assumption is inapplicable to functional predicate %s' % pred) for gndatom in self.mrf.gndatoms: if gndatom.predname != pred: continue if self.mrf.evidence[gndatom.idx] is None: self.mrf.evidence[gndatom.idx] = 0 # apply the closed world assumption to all remaining ground atoms that are not in the queries if self.closedworld: qpreds = set() for q in self.queries: qpreds.update(q.prednames()) for gndatom in self.mrf.gndatoms: if isinstance(self.mln.predicate(gndatom.predname), FunctionalPredicate) \ or isinstance(self.mln.predicate(gndatom.predname), SoftFunctionalPredicate): continue if gndatom.predname not in qpreds and self.mrf.evidence[ gndatom.idx] is None: self.mrf.evidence[gndatom.idx] = 0 for var in self.mrf.variables: if isinstance(var, FuzzyVariable): var.consistent(self.mrf.evidence, strict=True) self._watch = StopWatch()
def __init__(self, mln_, dbs, method, **params): ''' :param dbs: list of :class:`mln.database.Database` objects to be used for learning. :param mln_: the MLN object to be used for learning :param method: the algorithm to be used for learning. Must be a class provided by :class:`mln.methods.LearningMethods`. :param **params: additional parameters handed over to the base learners. ''' self.dbs = dbs self._params = edict(params) if not mln_._materialized: self.mln = mln_.materialize(*dbs) else: self.mln = mln_ self.watch = StopWatch() self.learners = [None] * len(dbs) self.watch.tag('setup learners', verbose=self.verbose) if self.verbose: bar = ProgressBar(steps=len(dbs), color='green') if self.multicore: pool = Pool(maxtasksperchild=1) logger.debug('Setting up multi-core processing for {} cores'.format(pool._processes)) try: for i, learner in pool.imap(with_tracing(_setup_learner), self._iterdbs(method)): self.learners[i] = learner if self.verbose: bar.label('Database %d, %s' % ((i + 1), learner.name)) bar.inc() except Exception as e: logger.error('Error in child process. Terminating pool...') pool.close() raise e finally: pool.terminate() pool.join() else: for i, db in enumerate(self.dbs): _, learner = _setup_learner((i, self.mln, db, method, self._params + {'multicore': False})) self.learners[i] = learner if self.verbose: bar.label('Database %d, %s' % ((i + 1), learner.name)) bar.inc() if self.verbose: print 'set up', self.name self.watch.finish('setup learners')
def __init__(self, mln_, dbs, method, **params): ''' :param dbs: list of :class:`mln.database.Database` objects to be used for learning. :param mln_: the MLN object to be used for learning :param method: the algorithm to be used for learning. Must be a class provided by :class:`mln.methods.LearningMethods`. :param **params: additional parameters handed over to the base learners. ''' self.dbs = dbs self._params = edict(params) if not mln_._materialized: self.mln = mln_.materialize(*dbs) else: self.mln = mln_ self.watch = StopWatch() self.learners = [None] * len(dbs) self.watch.tag('setup learners', verbose=self.verbose) if self.verbose: bar = ProgressBar(width=100, steps=len(dbs), color='green') if self.multicore: pool = Pool(maxtasksperchild=1) logger.debug('Setting up multi-core processing for %d cores' % pool._processes) for i, learner in pool.imap(with_tracing(_setup_learner), self._iterdbs(method)): self.learners[i] = learner if self.verbose: bar.label('Database %d, %s' % ((i + 1), learner.name)) bar.inc() pool.close() pool.join() else: for i, db in enumerate(self.dbs): _, learner = _setup_learner( (i, self.mln, db, method, self._params + { 'multicore': False })) self.learners[i] = learner if self.verbose: bar.label('Database %d, %s' % ((i + 1), learner.name)) bar.inc() if self.verbose: print 'set up', self.name self.watch.finish('setup learners')
def __init__(self, mrf, queries=ALL, **params): self.mrf = mrf self.mln = mrf.mln self._params = edict(params) if not queries: self.queries = [self.mln.logic.gnd_lit(ga, negated=False, mln=self.mln) for ga in self.mrf.gndatoms if self.mrf.evidence[ga.idx] is None] else: # check for single/multiple query and expand if type(queries) is not list: queries = [queries] self.queries = self._expand_queries(queries) # fill in the missing truth values of variables that have only one remaining value for variable in self.mrf.variables: if variable.valuecount(self.mrf.evidence_dicti()) == 1: # the var is fully determined by the evidence for _, value in variable.itervalues(self.mrf.evidence): break self.mrf.set_evidence(variable.value2dict(value), erase=False) # apply the closed world assumptions to the explicitly specified predicates if self.cwpreds: for pred in self.cwpreds: if isinstance(self.mln.predicate(pred), SoftFunctionalPredicate): if self.verbose: logger.warning('Closed world assumption will be applied to soft functional predicate %s' % pred) elif isinstance(self.mln.predicate(pred), FunctionalPredicate): raise Exception('Closed world assumption is inapplicable to functional predicate %s' % pred) for gndatom in self.mrf.gndatoms: if gndatom.predname != pred: continue if self.mrf.evidence[gndatom.idx] is None: self.mrf.evidence[gndatom.idx] = 0 # apply the closed world assumption to all remaining ground atoms that are not in the queries if self.closedworld: qpreds = set() for q in self.queries: qpreds.update(q.prednames()) for gndatom in self.mrf.gndatoms: if isinstance(self.mln.predicate(gndatom.predname), FunctionalPredicate) \ or isinstance(self.mln.predicate(gndatom.predname), SoftFunctionalPredicate): continue if gndatom.predname not in qpreds and self.mrf.evidence[gndatom.idx] is None: self.mrf.evidence[gndatom.idx] = 0 for var in self.mrf.variables: if isinstance(var, FuzzyVariable): var.consistent(self.mrf.evidence, strict=True) self._watch = StopWatch()
def tojson(self): return tojson(edict({constants.JSON_HOWTO_IMPORT_DATE: self.import_date}) +\ edict(Frame.tojson(self)) + edict({constants.JSON_HOWTO_STEPS: tojson(self.steps)}))