| from dreamcoder.utilities import * |
| from dreamcoder.program import * |
| from dreamcoder.task import Task |
|
|
|
|
| class FrontierEntry(object): |
| def __init__( |
| self, |
| program, |
| _=None, |
| logPrior=None, |
| logLikelihood=None, |
| logPosterior=None): |
| self.logPosterior = logPrior + logLikelihood if logPosterior is None else logPosterior |
| self.program = program |
| self.logPrior = logPrior |
| self.logLikelihood = logLikelihood |
|
|
| def __repr__(self): |
| return "FrontierEntry(program={self.program}, logPrior={self.logPrior}, logLikelihood={self.logLikelihood}".format( |
| self=self) |
|
|
| def strip_primitive_values(self): |
| return FrontierEntry(program=strip_primitive_values(self.program), |
| logPrior=self.logPrior, |
| logPosterior=self.logPosterior, |
| logLikelihood=self.logLikelihood) |
| def unstrip_primitive_values(self): |
| return FrontierEntry(program=unstrip_primitive_values(self.program), |
| logPrior=self.logPrior, |
| logPosterior=self.logPosterior, |
| logLikelihood=self.logLikelihood) |
|
|
|
|
| class Frontier(object): |
| def __init__(self, frontier, task): |
| self.entries = frontier |
| self.task = task |
|
|
| def __repr__( |
| self): return "Frontier(entries={self.entries}, task={self.task})".format(self=self) |
|
|
| def __iter__(self): return iter(self.entries) |
|
|
| def __len__(self): return len(self.entries) |
|
|
| def json(self): |
| return {"request": self.task.request.json(), |
| "task": str(self.task), |
| "programs": [{"program": str(e.program), |
| "logLikelihood": e.logLikelihood} |
| for e in self ]} |
|
|
| def strip_primitive_values(self): |
| return Frontier([e.strip_primitive_values() for e in self.entries ], |
| self.task) |
| def unstrip_primitive_values(self): |
| return Frontier([e.unstrip_primitive_values() for e in self.entries ], |
| self.task) |
|
|
| DUMMYFRONTIERCOUNTER = 0 |
|
|
| @staticmethod |
| def dummy(program, logLikelihood=0., logPrior=0., tp=None): |
| """Creates a dummy frontier containing just this program""" |
| if not tp: |
| tp = program.infer().negateVariables() |
|
|
| t = Task( |
| "<dummy %d: %s>" % |
| (Frontier.DUMMYFRONTIERCOUNTER, |
| str(program)), |
| tp, |
| []) |
| f = Frontier([FrontierEntry(program=program, |
| logLikelihood=logLikelihood, |
| logPrior=logPrior)], |
| task=t) |
| Frontier.DUMMYFRONTIERCOUNTER += 1 |
| return f |
|
|
| def marginalLikelihood(self): |
| return lse([e.logPrior + e.logLikelihood for e in self]) |
|
|
| def temperature(self,T): |
| """Divides prior by T""" |
| return Frontier([ FrontierEntry(program=e.program, |
| logPrior=e.logPrior/T, |
| logLikelihood=e.logLikelihood) |
| for e in self], |
| task=self.task) |
| |
|
|
| def normalize(self): |
| z = self.marginalLikelihood() |
| newEntries = [ |
| FrontierEntry( |
| program=e.program, |
| logPrior=e.logPrior, |
| logLikelihood=e.logLikelihood, |
| logPosterior=e.logPrior + |
| e.logLikelihood - |
| z) for e in self] |
| newEntries.sort(key=lambda e: e.logPosterior, reverse=True) |
| return Frontier(newEntries, |
| self.task) |
|
|
| def expectedProductionUses(self, g): |
| """Returns a vector of the expected number of times each production was used""" |
| import numpy as np |
|
|
| this = g.rescoreFrontier(self).normalize() |
| ps = list(sorted(g.primitives, key=str)) |
| features = np.zeros(len(ps)) |
| |
| for j, p in enumerate(ps): |
| for e in this: |
| w = math.exp(e.logPosterior) |
| features[j] += w * sum(child == p |
| for _, child in e.program.walk() ) |
| if not p.isInvented: features[j] *= 0.3 |
| return features |
| |
|
|
| def removeZeroLikelihood(self): |
| self.entries = [ |
| e for e in self.entries if e.logLikelihood != float('-inf')] |
| return self |
|
|
| def topK(self, k): |
| if k == 0: return Frontier([], self.task) |
| if k < 0: return self |
| newEntries = sorted(self.entries, |
| key=lambda e: (-e.logPosterior, str(e.program))) |
| return Frontier(newEntries[:k], self.task) |
|
|
| def sample(self): |
| """Samples an entry from a frontier""" |
| return sampleLogDistribution([(e.logLikelihood + e.logPrior, e) |
| for e in self]) |
|
|
| @property |
| def bestPosterior(self): |
| return min(self.entries, |
| key=lambda e: (-e.logPosterior, str(e.program))) |
|
|
| def replaceWithSupervised(self, g): |
| assert self.task.supervision is not None |
| return g.rescoreFrontier(Frontier([FrontierEntry(self.task.supervision, |
| logLikelihood=0., logPrior=0.)], |
| task=self.task)) |
|
|
| @property |
| def bestll(self): |
| best = max(self.entries, |
| key=lambda e: e.logLikelihood) |
| return best.logLikelihood |
|
|
|
|
| @property |
| def empty(self): return self.entries == [] |
|
|
| @staticmethod |
| def makeEmpty(task): |
| return Frontier([], task=task) |
|
|
| def summarize(self): |
| if self.empty: |
| return "MISS " + self.task.name |
| best = self.bestPosterior |
| return "HIT %s w/ %s ; log prior = %f ; log likelihood = %f" % ( |
| self.task.name, best.program, best.logPrior, best.logLikelihood) |
|
|
| def summarizeFull(self): |
| if self.empty: |
| return "MISS " + self.task.name |
| return "\n".join([self.task.name] + |
| ["%f\t%s" % (e.logPosterior, e.program) |
| for e in self.normalize()]) |
|
|
| @staticmethod |
| def describe(frontiers): |
| numberOfHits = sum(not f.empty for f in frontiers) |
| if numberOfHits > 0: |
| averageLikelihood = sum( |
| f.bestPosterior.logPrior for f in frontiers if not f.empty) / numberOfHits |
| else: |
| averageLikelihood = 0 |
| return "\n".join([f.summarize() for f in frontiers] + |
| ["Hits %d/%d tasks" % (numberOfHits, len(frontiers))] + |
| ["Average description length of a program solving a task: %f nats" % (-averageLikelihood)]) |
|
|
| def combine(self, other, tolerance=0.01): |
| '''Takes the union of the programs in each of the frontiers''' |
| assert self.task == other.task |
|
|
| foundDifference = False |
|
|
| x = {e.program: e for e in self} |
| y = {e.program: e for e in other} |
| programs = set(x.keys()) | set(y.keys()) |
| union = [] |
| for p in programs: |
| if p in x: |
| e1 = x[p] |
| if p in y: |
| e2 = y[p] |
| if abs(e1.logPrior - e2.logPrior) > tolerance: |
| eprint( |
| "WARNING: Log priors differed during frontier combining: %f vs %f" % |
| (e1.logPrior, e2.logPrior)) |
| eprint("WARNING: \tThe program is", p) |
| eprint() |
| if abs(e1.logLikelihood - e2.logLikelihood) > tolerance: |
| foundDifference = True |
| eprint( |
| "WARNING: Log likelihoods deferred for %s: %f & %f" % |
| (p, e1.logLikelihood, e2.logLikelihood)) |
| if hasattr(self.task, 'BIC'): |
| eprint("\t%d examples, BIC=%f, parameterPenalty=%f, n parameters=%d, correct likelihood=%f" % |
| (len(self.task.examples), |
| self.task.BIC, |
| self.task.BIC * math.log(len(self.task.examples)), |
| substringOccurrences("REAL", str(p)), |
| substringOccurrences("REAL", str(p)) * self.task.BIC * math.log(len(self.task.examples)))) |
| e1.logLikelihood = - \ |
| substringOccurrences("REAL", str(p)) * self.task.BIC * math.log(len(self.task.examples)) |
| e2.logLikelihood = e1.logLikelihood |
|
|
| e1 = FrontierEntry( |
| program=e1.program, |
| logLikelihood=( |
| e1.logLikelihood + |
| e2.logLikelihood) / |
| 2, |
| logPrior=e1.logPrior) |
| else: |
| e1 = y[p] |
| union.append(e1) |
|
|
| if foundDifference: |
| eprint( |
| "WARNING: Log likelihoods differed for the same program on the task %s.\n" % |
| (self.task.name), |
| "\tThis is acceptable only if the likelihood model is stochastic. Took the geometric mean of the likelihoods.") |
|
|
| return Frontier(union, self.task) |
|
|
