def __init__(self, mrf, queries=ALL, state=None, **params): MCMCInference.__init__(self, mrf, queries, **params) if state is None: self.state = self.random_world(self.mrf.evidence) else: self.state = state self.sum = 0 self.var2gf = defaultdict(set) self.weights = list(self.mrf.mln.weights) formulas = [] for f in self.mrf.formulas: if f.weight < 0: f_ = self.mrf.mln.logic.negate(f) f_.weight = -f.weight formulas.append(f_.nnf()) grounder = FastConjunctionGrounding(mrf, formulas=formulas, simplify=True, unsatfailure=True) for gf in grounder.itergroundings(): if isinstance(gf, Logic.TrueFalse): continue vars_ = set(map(lambda a: self.mrf.variable(a).idx, gf.gndatoms())) for v in vars_: self.var2gf[v].add(gf) self.sum += (self.hardw if gf.weight == HARD else gf.weight) * (1 - gf(self.state))
def __init__(self, mrf, queries=ALL, **params): MCMCInference.__init__(self, mrf, queries, **params) self.var2gf = defaultdict(set) grounder = FastConjunctionGrounding(mrf, simplify=True, unsatfailure=True, cache=None) for gf in grounder.itergroundings(): if isinstance(gf, Logic.TrueFalse): continue vars_ = set(map(lambda a: self.mrf.variable(a).idx, gf.gndatoms())) for v in vars_: self.var2gf[v].add(gf)
def __init__(self, mrf, queries=ALL, state=None, **params): MCMCInference.__init__(self, mrf, queries, **params) if state is None: self.state = self.random_world(self.mrf.evidence) else: self.state = state self.sum = 0 self.var2gf = defaultdict(set) self.weights = list(self.mrf.mln.weights) formulas = [] for f in self.mrf.formulas: if f.weight < 0: f_ = self.mrf.mln.logic.negate(f) f_.weight = - f.weight formulas.append(f_.nnf()) grounder = FastConjunctionGrounding(mrf, formulas=formulas, simplify=True, unsatfailure=True) for gf in grounder.itergroundings(): if isinstance(gf, Logic.TrueFalse): continue vars_ = set(map(lambda a: self.mrf.variable(a).idx, gf.gndatoms())) for v in vars_: self.var2gf[v].add(gf) self.sum += (self.hardw if gf.weight == HARD else gf.weight) * (1 - gf(self.state))
def _run(self, **params): ''' infer one or more probabilities P(F1 | F2) what: a ground formula (string) or a list of ground formulas (list of strings) (F1) given: a formula as a string (F2) set evidence according to given conjunction (if any) ''' # if softEvidence is None: # self.softEvidence = self.mln.softEvidence # else: # self.softEvidence = softEvidence # initialize chains chains = MCMCInference.ChainGroup(self) for i in range(self.chains): chain = GibbsSampler.Chain(self, self.queries) chains.chain(chain) # if self.softEvidence is not None: # chain.setSoftEvidence(self.softEvidence) # do Gibbs sampling # if verbose and details: print "sampling..." converged = 0 steps = 0 if self.verbose: bar = ProgressBar(color='green', steps=self.maxsteps) while converged != self.chains and steps < self.maxsteps: converged = 0 steps += 1 for chain in chains.chains: chain.step() if self.verbose: bar.inc() bar.label('%d / %d' % (steps, self.maxsteps)) # if self.useConvergenceTest: # if chain.converged and numSteps >= minSteps: # converged += 1 # if verbose and details: # if numSteps % infoInterval == 0: # print "step %d (fraction converged: %.2f)" % (numSteps, float(converged) / numChains) # if numSteps % resultsInterval == 0: # chainGroup.getResults() # chainGroup.printResults(shortOutput=True) # get the results return chains.results()[0]
def __init__(self, mrf, queries=ALL, **params): MCMCInference.__init__(self, mrf, queries, **params) self._weight_backup = list(self.mrf.mln.weights)
def _run(self): ''' p: probability of a greedy (WalkSAT) move initAlgo: algorithm to use in order to find an initial state that satisfies all hard constraints ("SampleSAT" or "SAMaxWalkSat") verbose: whether to display results upon completion details: whether to display information while the algorithm is running infoInterval: [if details==True] interval (no. of steps) in which to display the current step number and some additional info resultsInterval: [if details==True] interval (no. of steps) in which to display intermediate results; [if keepResultsHistory==True] interval in which to store intermediate results in the history debug: whether to display debug information (e.g. internal data structures) while the algorithm is running debugLevel: controls degree to which debug information is presented keepResultsHistory: whether to store the history of results (at each resultsInterval) referenceResults: reference results to compare obtained results to saveHistoryFile: if not None, save history to given filename sampleCallback: function that is called for every sample with the sample and step number as parameters softEvidence: if None, use soft evidence from MLN, otherwise use given dictionary of soft evidence handleSoftEvidence: if False, ignore all soft evidence in the MCMC sampling (but still compute softe evidence statistics if soft evidence is there) ''' logger.debug("starting MC-SAT with maxsteps=%d, softevidence=%s" % (self.maxsteps, self.softevidence)) # initialize the KB and gather required info self._initkb() # print CNF KB logger.debug("CNF KB:") for gf in self.gndformulas: logger.debug("%7.3f %s" % (gf.weight, str(gf))) print # set the random seed if it was given if self.rndseed is not None: random.seed(self.rndseed) # create chains chaingroup = MCMCInference.ChainGroup(self) self.chaingroup = chaingroup for i in range(self.chains): chain = MCMCInference.Chain(self, self.queries) chaingroup.chain(chain) # satisfy hard constraints using initialization algorithm M = [] NLC = [] for i, gf in enumerate(self.gndformulas): if gf.weight == HARD: if gf.islogical(): clause_range = self.gf2clauseidx[i] M.extend(range(*clause_range)) else: NLC.append(gf) if M or NLC: logger.debug('Running SampleSAT') chain.state = SampleSAT( self.mrf, chain.state, M, NLC, self, p=self.p ).run( ) # Note: can't use p=1.0 because there is a chance of getting into an oscillating state if logger.level == logs.DEBUG: self.mrf.print_world_vars(chain.state) self.step = 1 logger.debug('running MC-SAT with %d chains' % len(chaingroup.chains)) self._watch.tag('running MC-SAT', self.verbose) if self.verbose: bar = ProgressBar(steps=self.maxsteps, color='green') while self.step <= self.maxsteps: # take one step in each chain for chain in chaingroup.chains: # choose a subset of the satisfied formulas and sample a state that satisfies them state = self._satisfy_subset(chain) # update chain counts chain.update(state) if self.verbose: bar.inc() bar.label('%d / %d' % (self.step, self.maxsteps)) # intermediate results self.step += 1 # get results self.step -= 1 results = chaingroup.results() return results[0]