import datetime import dill from dreamcoder.compression import induceGrammar from dreamcoder.utilities import * try: from dreamcoder.recognition import * except: eprint("Failure loading recognition - only acceptable if using pypy ") from dreamcoder.enumeration import * from dreamcoder.fragmentGrammar import * from dreamcoder.taskBatcher import * from dreamcoder.primitiveGraph import graphPrimitives from dreamcoder.dreaming import backgroundHelmholtzEnumeration class ECResult(): def __init__(self, _=None, frontiersOverTime=None, testingSearchTime=None, learningCurve=None, grammars=None, taskSolutions=None, averageDescriptionLength=None, parameters=None, recognitionModel=None, searchTimes=None, recognitionTaskMetrics=None, numTestingTasks=None, sumMaxll=None, testingSumMaxll=None, hitsAtEachWake=None, timesAtEachWake=None, allFrontiers=None): self.frontiersOverTime = {} # Map from task to [frontier at iteration 1, frontier at iteration 2, ...] self.hitsAtEachWake = hitsAtEachWake or [] self.timesAtEachWake = timesAtEachWake or [] self.testingSearchTime = testingSearchTime or [] self.searchTimes = searchTimes or [] self.trainSearchTime = {} # map from task to search time self.testSearchTime = {} # map from task to search time self.recognitionTaskMetrics = recognitionTaskMetrics or {} self.recognitionModel = recognitionModel self.averageDescriptionLength = averageDescriptionLength or [] self.parameters = parameters self.learningCurve = learningCurve or [] self.grammars = grammars or [] self.taskSolutions = taskSolutions or {} self.numTestingTasks = numTestingTasks self.sumMaxll = sumMaxll or [] #TODO name change self.testingSumMaxll = testingSumMaxll or [] #TODO name change self.allFrontiers = allFrontiers or {} def __repr__(self): attrs = ["{}={}".format(k, v) for k, v in self.__dict__.items()] return "ECResult({})".format(", ".join(attrs)) def getTestingTasks(self): testing = [] training = self.taskSolutions.keys() for t in self.recognitionTaskMetrics: if isinstance(t, Task) and t not in training: testing.append(t) return testing def recordFrontier(self, frontier): t = frontier.task if t not in self.frontiersOverTime: self.frontiersOverTime[t] = [] self.frontiersOverTime[t].append(frontier) # Linux does not like files that have more than 256 characters # So when exporting the results we abbreviate the parameters abbreviations = {"frontierSize": "fs", "useDSL": "DSL", "taskReranker": "TRR", "matrixRank": "MR", "reuseRecognition": "RR", "ensembleSize": "ES", "recognitionTimeout": "RT", "recognitionSteps": "RS", "iterations": "it", "maximumFrontier": "MF", "pseudoCounts": "pc", "auxiliaryLoss": "aux", "structurePenalty": "L", "helmholtzRatio": "HR", "biasOptimal": "BO", "contextual": "CO", "topK": "K", "enumerationTimeout": "ET", "useRecognitionModel": "rec", "use_ll_cutoff": "llcut", "topk_use_only_likelihood": "topkNotMAP", "activation": "act", "storeTaskMetrics": 'STM', "topkNotMAP": "tknm", "rewriteTaskMetrics": "RW", 'taskBatchSize': 'batch'} @staticmethod def abbreviate(parameter): return ECResult.abbreviations.get(parameter, parameter) @staticmethod def parameterOfAbbreviation(abbreviation): return ECResult.abbreviationToParameter.get(abbreviation, abbreviation) @staticmethod def clearRecognitionModel(path): SUFFIX = '.pickle' assert path.endswith(SUFFIX) with open(path,'rb') as handle: result = dill.load(handle) result.recognitionModel = None clearedPath = path[:-len(SUFFIX)] + "_graph=True" + SUFFIX with open(clearedPath,'wb') as handle: result = dill.dump(result, handle) eprint(" [+] Cleared recognition model from:") eprint(" %s"%path) eprint(" and exported to:") eprint(" %s"%clearedPath) eprint(" Use this one for graphing.") ECResult.abbreviationToParameter = { v: k for k, v in ECResult.abbreviations.items()} def explorationCompression(*arguments, **keywords): for r in ecIterator(*arguments, **keywords): pass return r def ecIterator(grammar, tasks, _=None, useDSL=True, noConsolidation=False, mask=False, seed=0, addFullTaskMetrics=False, matrixRank=None, solver='ocaml', compressor="rust", biasOptimal=False, contextual=False, testingTasks=[], iterations=None, resume=None, enumerationTimeout=None, testingTimeout=None, testEvery=1, reuseRecognition=False, ensembleSize=1, useRecognitionModel=True, recognitionTimeout=None, recognitionSteps=None, helmholtzRatio=0., featureExtractor=None, activation='relu', topK=1, topk_use_only_likelihood=False, use_map_search_times=True, maximumFrontier=None, pseudoCounts=1.0, aic=1.0, structurePenalty=0.001, arity=0, evaluationTimeout=1.0, # seconds taskBatchSize=None, taskReranker='default', CPUs=1, cuda=False, message="", outputPrefix=None, storeTaskMetrics=False, rewriteTaskMetrics=True, auxiliaryLoss=False, custom_wake_generative=None): if enumerationTimeout is None: eprint( "Please specify an enumeration timeout:", "explorationCompression(..., enumerationTimeout = ..., ...)") assert False if iterations is None: eprint( "Please specify a iteration count: explorationCompression(..., iterations = ...)") assert False if useRecognitionModel and featureExtractor is None: eprint("Warning: Recognition model needs feature extractor.", "Ignoring recognition model.") useRecognitionModel = False if ensembleSize > 1 and not useRecognitionModel: eprint("Warning: ensemble size requires using the recognition model, aborting.") assert False if biasOptimal and not useRecognitionModel: eprint("Bias optimality only applies to recognition models, aborting.") assert False if contextual and not useRecognitionModel: eprint("Contextual only applies to recognition models, aborting") assert False if reuseRecognition and not useRecognitionModel: eprint("Reuse of recognition model weights at successive iteration only applies to recognition models, aborting") assert False if matrixRank is not None and not contextual: eprint("Matrix rank only applies to contextual recognition models, aborting") assert False assert useDSL or useRecognitionModel, "You specified that you didn't want to use the DSL AND you don't want to use the recognition model. Figure out what you want to use." if testingTimeout > 0 and len(testingTasks) == 0: eprint("You specified a testingTimeout, but did not provide any held out testing tasks, aborting.") assert False # We save the parameters that were passed into EC # This is for the purpose of exporting the results of the experiment parameters = { k: v for k, v in locals().items() if k not in { "tasks", "use_map_search_times", "seed", "activation", "grammar", "cuda", "_", "testingTimeout", "testEvery", "message", "CPUs", "outputPrefix", "resume", "resumeFrontierSize", "addFullTaskMetrics", "featureExtractor", "evaluationTimeout", "testingTasks", "compressor", "custom_wake_generative"} and v is not None} if not useRecognitionModel: for k in {"helmholtzRatio", "recognitionTimeout", "biasOptimal", "mask", "contextual", "matrixRank", "reuseRecognition", "auxiliaryLoss", "ensembleSize"}: if k in parameters: del parameters[k] else: del parameters["useRecognitionModel"]; if useRecognitionModel and not contextual: if "matrixRank" in parameters: del parameters["matrixRank"] if "mask" in parameters: del parameters["mask"] if not mask and 'mask' in parameters: del parameters["mask"] if not auxiliaryLoss and 'auxiliaryLoss' in parameters: del parameters['auxiliaryLoss'] if not useDSL: for k in {"structurePenalty", "pseudoCounts", "aic"}: del parameters[k] else: del parameters["useDSL"] # Uses `parameters` to construct the checkpoint path def checkpointPath(iteration, extra=""): parameters["iterations"] = iteration kvs = [ "{}={}".format( ECResult.abbreviate(k), parameters[k]) for k in sorted( parameters.keys())] return "{}_{}{}.pickle".format(outputPrefix, "_".join(kvs), extra) if message: message = " (" + message + ")" eprint("Running EC%s on %s @ %s with %d CPUs and parameters:" % (message, os.uname()[1], datetime.datetime.now(), CPUs)) for k, v in parameters.items(): eprint("\t", k, " = ", v) eprint("\t", "evaluationTimeout", " = ", evaluationTimeout) eprint("\t", "cuda", " = ", cuda) eprint() if addFullTaskMetrics: assert resume is not None, "--addFullTaskMetrics requires --resume" def reportMemory(): eprint(f"Currently using this much memory: {getThisMemoryUsage()}") # Restore checkpoint if resume is not None: try: resume = int(resume) path = checkpointPath(resume) except ValueError: path = resume with open(path, "rb") as handle: result = dill.load(handle) resume = len(result.grammars) - 1 eprint("Loaded checkpoint from", path) grammar = result.grammars[-1] if result.grammars else grammar else: # Start from scratch #for graphing of testing tasks numTestingTasks = len(testingTasks) if len(testingTasks) != 0 else None result = ECResult(parameters=parameters, grammars=[grammar], taskSolutions={ t: Frontier([], task=t) for t in tasks}, recognitionModel=None, numTestingTasks=numTestingTasks, allFrontiers={ t: Frontier([], task=t) for t in tasks}) # Set up the task batcher. if taskReranker == 'default': taskBatcher = DefaultTaskBatcher() elif taskReranker == 'random': taskBatcher = RandomTaskBatcher() elif taskReranker == 'randomShuffle': taskBatcher = RandomShuffleTaskBatcher(seed) elif taskReranker == 'unsolved': taskBatcher = UnsolvedTaskBatcher() elif taskReranker == 'unsolvedEntropy': taskBatcher = UnsolvedEntropyTaskBatcher() elif taskReranker == 'unsolvedRandomEntropy': taskBatcher = UnsolvedRandomEntropyTaskBatcher() elif taskReranker == 'randomkNN': taskBatcher = RandomkNNTaskBatcher() elif taskReranker == 'randomLowEntropykNN': taskBatcher = RandomLowEntropykNNTaskBatcher() else: eprint("Invalid task reranker: " + taskReranker + ", aborting.") assert False # Check if we are just updating the full task metrics if addFullTaskMetrics: if testingTimeout is not None and testingTimeout > enumerationTimeout: enumerationTimeout = testingTimeout if result.recognitionModel is not None: _enumerator = lambda *args, **kw: result.recognitionModel.enumerateFrontiers(*args, **kw) else: _enumerator = lambda *args, **kw: multicoreEnumeration(result.grammars[-1], *args, **kw) enumerator = lambda *args, **kw: _enumerator(*args, maximumFrontier=maximumFrontier, CPUs=CPUs, evaluationTimeout=evaluationTimeout, solver=solver, **kw) trainFrontiers, _, trainingTimes = enumerator(tasks, enumerationTimeout=enumerationTimeout) testFrontiers, _, testingTimes = enumerator(testingTasks, enumerationTimeout=testingTimeout, testing=True) recognizer = result.recognitionModel updateTaskSummaryMetrics(result.recognitionTaskMetrics, trainingTimes, 'recognitionBestTimes') updateTaskSummaryMetrics(result.recognitionTaskMetrics, recognizer.taskGrammarLogProductions(tasks), 'taskLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, recognizer.taskGrammarEntropies(tasks), 'taskGrammarEntropies') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskAuxiliaryLossLayer(tasks), 'taskAuxiliaryLossLayer') updateTaskSummaryMetrics(result.recognitionTaskMetrics, testingTimes, 'heldoutTestingTimes') updateTaskSummaryMetrics(result.recognitionTaskMetrics, recognizer.taskGrammarLogProductions(testingTasks), 'heldoutTaskLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, recognizer.taskGrammarEntropies(testingTasks), 'heldoutTaskGrammarEntropies') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskAuxiliaryLossLayer(testingTasks), 'heldoutAuxiliaryLossLayer') updateTaskSummaryMetrics(result.recognitionTaskMetrics, {f.task: f for f in trainFrontiers + testFrontiers if len(f) > 0}, 'frontier') SUFFIX = ".pickle" assert path.endswith(SUFFIX) path = path[:-len(SUFFIX)] + "_FTM=True" + SUFFIX with open(path, "wb") as handle: dill.dump(result, handle) if useRecognitionModel: ECResult.clearRecognitionModel(path) sys.exit(0) for j in range(resume or 0, iterations): if storeTaskMetrics and rewriteTaskMetrics: eprint("Resetting task metrics for next iteration.") result.recognitionTaskMetrics = {} reportMemory() # Evaluate on held out tasks if we have them if testingTimeout > 0 and ((j % testEvery == 0) or (j == iterations - 1)): eprint("Evaluating on held out testing tasks for iteration: %d" % (j)) evaluateOnTestingTasks(result, testingTasks, grammar, CPUs=CPUs, maximumFrontier=maximumFrontier, solver=solver, enumerationTimeout=testingTimeout, evaluationTimeout=evaluationTimeout) # If we have to also enumerate Helmholtz frontiers, # do this extra sneaky in the background if useRecognitionModel and biasOptimal and helmholtzRatio > 0 and \ all( str(p) != "REAL" for p in grammar.primitives ): # real numbers don't support this # the DSL is fixed, so the dreams are also fixed. don't recompute them. if useDSL or 'helmholtzFrontiers' not in locals(): helmholtzFrontiers = backgroundHelmholtzEnumeration(tasks, grammar, enumerationTimeout, evaluationTimeout=evaluationTimeout, special=featureExtractor.special) else: print("Reusing dreams from previous iteration.") else: helmholtzFrontiers = lambda: [] reportMemory() # Get waking task batch. wakingTaskBatch = taskBatcher.getTaskBatch(result, tasks, taskBatchSize, j) eprint("Using a waking task batch of size: " + str(len(wakingTaskBatch))) # WAKING UP if useDSL: wake_generative = custom_wake_generative if custom_wake_generative is not None else default_wake_generative topDownFrontiers, times = wake_generative(grammar, wakingTaskBatch, solver=solver, maximumFrontier=maximumFrontier, enumerationTimeout=enumerationTimeout, CPUs=CPUs, evaluationTimeout=evaluationTimeout) result.trainSearchTime = {t: tm for t, tm in times.items() if tm is not None} else: eprint("Skipping top-down enumeration because we are not using the generative model") topDownFrontiers, times = [], {t: None for t in wakingTaskBatch } tasksHitTopDown = {f.task for f in topDownFrontiers if not f.empty} result.hitsAtEachWake.append(len(tasksHitTopDown)) reportMemory() # Combine topDownFrontiers from this task batch with all frontiers. for f in topDownFrontiers: if f.task not in result.allFrontiers: continue # backward compatibility with old checkpoints result.allFrontiers[f.task] = result.allFrontiers[f.task].combine(f).topK(maximumFrontier) eprint("Frontiers discovered top down: " + str(len(tasksHitTopDown))) eprint("Total frontiers: " + str(len([f for f in result.allFrontiers.values() if not f.empty]))) # Train + use recognition model if useRecognitionModel: # Should we initialize the weights to be what they were before? previousRecognitionModel = None if reuseRecognition and result.recognitionModel is not None: previousRecognitionModel = result.recognitionModel thisRatio = helmholtzRatio #if j == 0 and not biasOptimal: thisRatio = 0 if all( f.empty for f in result.allFrontiers.values() ): thisRatio = 1. tasksHitBottomUp = \ sleep_recognition(result, grammar, wakingTaskBatch, tasks, testingTasks, result.allFrontiers.values(), ensembleSize=ensembleSize, featureExtractor=featureExtractor, mask=mask, activation=activation, contextual=contextual, biasOptimal=biasOptimal, previousRecognitionModel=previousRecognitionModel, matrixRank=matrixRank, timeout=recognitionTimeout, evaluationTimeout=evaluationTimeout, enumerationTimeout=enumerationTimeout, helmholtzRatio=thisRatio, helmholtzFrontiers=helmholtzFrontiers(), auxiliaryLoss=auxiliaryLoss, cuda=cuda, CPUs=CPUs, solver=solver, recognitionSteps=recognitionSteps, maximumFrontier=maximumFrontier) showHitMatrix(tasksHitTopDown, tasksHitBottomUp, wakingTaskBatch) # Record the new topK solutions result.taskSolutions = {f.task: f.topK(topK) for f in result.allFrontiers.values()} for f in result.allFrontiers.values(): result.recordFrontier(f) result.learningCurve += [ sum(f is not None and not f.empty for f in result.taskSolutions.values())] updateTaskSummaryMetrics(result.recognitionTaskMetrics, {f.task: f for f in result.allFrontiers.values() if len(f) > 0}, 'frontier') # Sleep-G if useDSL and not(noConsolidation): eprint(f"Currently using this much memory: {getThisMemoryUsage()}") grammar = consolidate(result, grammar, topK=topK, pseudoCounts=pseudoCounts, arity=arity, aic=aic, structurePenalty=structurePenalty, compressor=compressor, CPUs=CPUs, iteration=j) eprint(f"Currently using this much memory: {getThisMemoryUsage()}") else: eprint("Skipping consolidation.") result.grammars.append(grammar) if outputPrefix is not None: path = checkpointPath(j + 1) with open(path, "wb") as handle: try: dill.dump(result, handle) except TypeError as e: eprint(result) assert(False) eprint("Exported checkpoint to", path) if useRecognitionModel: ECResult.clearRecognitionModel(path) graphPrimitives(result, "%s_primitives_%d_"%(outputPrefix,j)) yield result def showHitMatrix(top, bottom, tasks): tasks = set(tasks) total = bottom | top eprint(len(total), "/", len(tasks), "total hit tasks") bottomMiss = tasks - bottom topMiss = tasks - top eprint("{: <13s}{: ^13s}{: ^13s}".format("", "bottom miss", "bottom hit")) eprint("{: <13s}{: ^13d}{: ^13d}".format("top miss", len(bottomMiss & topMiss), len(bottom & topMiss))) eprint("{: <13s}{: ^13d}{: ^13d}".format("top hit", len(top & bottomMiss), len(top & bottom))) def evaluateOnTestingTasks(result, testingTasks, grammar, _=None, CPUs=None, solver=None, maximumFrontier=None, enumerationTimeout=None, evaluationTimeout=None): if result.recognitionModel is not None: recognizer = result.recognitionModel testingFrontiers, times = \ recognizer.enumerateFrontiers(testingTasks, CPUs=CPUs, solver=solver, maximumFrontier=maximumFrontier, enumerationTimeout=enumerationTimeout, evaluationTimeout=evaluationTimeout, testing=True) updateTaskSummaryMetrics(result.recognitionTaskMetrics, recognizer.taskGrammarLogProductions(testingTasks), 'heldoutTaskLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, recognizer.taskGrammarEntropies(testingTasks), 'heldoutTaskGrammarEntropies') updateTaskSummaryMetrics(result.recognitionTaskMetrics, recognizer.taskGrammarEntropies(testingTasks), 'heldoutTaskGrammarEntropies') else: testingFrontiers, times = multicoreEnumeration(grammar, testingTasks, solver=solver, maximumFrontier=maximumFrontier, enumerationTimeout=enumerationTimeout, CPUs=CPUs, evaluationTimeout=evaluationTimeout, testing=True) updateTaskSummaryMetrics(result.recognitionTaskMetrics, times, 'heldoutTestingTimes') updateTaskSummaryMetrics(result.recognitionTaskMetrics, {f.task: f for f in testingFrontiers if len(f) > 0 }, 'frontier') for f in testingFrontiers: result.recordFrontier(f) result.testSearchTime = {t: tm for t, tm in times.items() if tm is not None} times = [t for t in times.values() if t is not None ] eprint("\n".join(f.summarize() for f in testingFrontiers)) summaryStatistics("Testing tasks", times) eprint("Hits %d/%d testing tasks" % (len(times), len(testingTasks))) result.testingSearchTime.append(times) def default_wake_generative(grammar, tasks, maximumFrontier=None, enumerationTimeout=None, CPUs=None, solver=None, evaluationTimeout=None): topDownFrontiers, times = multicoreEnumeration(grammar, tasks, maximumFrontier=maximumFrontier, enumerationTimeout=enumerationTimeout, CPUs=CPUs, solver=solver, evaluationTimeout=evaluationTimeout) eprint("Generative model enumeration results:") eprint(Frontier.describe(topDownFrontiers)) summaryStatistics("Generative model", [t for t in times.values() if t is not None]) return topDownFrontiers, times def sleep_recognition(result, grammar, taskBatch, tasks, testingTasks, allFrontiers, _=None, ensembleSize=1, featureExtractor=None, matrixRank=None, mask=False, activation=None, contextual=True, biasOptimal=True, previousRecognitionModel=None, recognitionSteps=None, timeout=None, enumerationTimeout=None, evaluationTimeout=None, helmholtzRatio=None, helmholtzFrontiers=None, maximumFrontier=None, auxiliaryLoss=None, cuda=None, CPUs=None, solver=None): eprint("Using an ensemble size of %d. Note that we will only store and test on the best recognition model." % ensembleSize) featureExtractorObjects = [featureExtractor(tasks, testingTasks=testingTasks, cuda=cuda) for i in range(ensembleSize)] recognizers = [RecognitionModel(featureExtractorObjects[i], grammar, mask=mask, rank=matrixRank, activation=activation, cuda=cuda, contextual=contextual, previousRecognitionModel=previousRecognitionModel, id=i) for i in range(ensembleSize)] eprint(f"Currently using this much memory: {getThisMemoryUsage()}") trainedRecognizers = parallelMap(min(CPUs,len(recognizers)), lambda recognizer: recognizer.train(allFrontiers, biasOptimal=biasOptimal, helmholtzFrontiers=helmholtzFrontiers, CPUs=CPUs, evaluationTimeout=evaluationTimeout, timeout=timeout, steps=recognitionSteps, helmholtzRatio=helmholtzRatio, auxLoss=auxiliaryLoss, vectorized=True), recognizers, seedRandom=True) eprint(f"Currently using this much memory: {getThisMemoryUsage()}") # Enumerate frontiers for each of the recognizers. eprint("Trained an ensemble of %d recognition models, now enumerating." % len(trainedRecognizers)) ensembleFrontiers, ensembleTimes, ensembleRecognitionTimes = [], [], [] mostTasks = 0 bestRecognizer = None totalTasksHitBottomUp = set() for recIndex, recognizer in enumerate(trainedRecognizers): eprint("Enumerating from recognizer %d of %d" % (recIndex, len(trainedRecognizers))) bottomupFrontiers, allRecognitionTimes = \ recognizer.enumerateFrontiers(taskBatch, CPUs=CPUs, maximumFrontier=maximumFrontier, enumerationTimeout=enumerationTimeout, evaluationTimeout=evaluationTimeout, solver=solver) ensembleFrontiers.append(bottomupFrontiers) ensembleTimes.append([t for t in allRecognitionTimes.values() if t is not None]) ensembleRecognitionTimes.append(allRecognitionTimes) recognizerTasksHitBottomUp = {f.task for f in bottomupFrontiers if not f.empty} totalTasksHitBottomUp.update(recognizerTasksHitBottomUp) eprint("Recognizer %d solved %d/%d tasks; total tasks solved is now %d." % (recIndex, len(recognizerTasksHitBottomUp), len(tasks), len(totalTasksHitBottomUp))) if len(recognizerTasksHitBottomUp) >= mostTasks: # TODO (cathywong): could consider keeping the one that put the highest likelihood on the solved tasks. bestRecognizer = recIndex # Store the recognizer that discovers the most frontiers in the result. eprint("Best recognizer: %d." % bestRecognizer) result.recognitionModel = trainedRecognizers[bestRecognizer] result.trainSearchTime = {tk: tm for tk, tm in ensembleRecognitionTimes[bestRecognizer].items() if tm is not None} updateTaskSummaryMetrics(result.recognitionTaskMetrics, ensembleRecognitionTimes[bestRecognizer], 'recognitionBestTimes') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskHiddenStates(tasks), 'hiddenState') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarLogProductions(tasks), 'taskLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarEntropies(tasks), 'taskGrammarEntropies') if contextual: updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarStartProductions(tasks), 'startProductions') result.hitsAtEachWake.append(len(totalTasksHitBottomUp)) eprint(f"Currently using this much memory: {getThisMemoryUsage()}") """ Rescore and combine the frontiers across the ensemble of recognition models.""" eprint("Recognition model enumeration results for the best recognizer.") eprint(Frontier.describe(ensembleFrontiers[bestRecognizer])) summaryStatistics("Recognition model", ensembleTimes[bestRecognizer]) eprint("Cumulative results for the full ensemble of %d recognizers: " % len(trainedRecognizers)) # Rescore all of the ensemble frontiers according to the generative model # and then combine w/ original frontiers for bottomupFrontiers in ensembleFrontiers: for b in bottomupFrontiers: if b.task not in result.allFrontiers: continue # backwards compatibility with old checkpoints result.allFrontiers[b.task] = result.allFrontiers[b.task].\ combine(grammar.rescoreFrontier(b)).\ topK(maximumFrontier) eprint("Frontiers discovered bottom up: " + str(len(totalTasksHitBottomUp))) eprint("Total frontiers: " + str(len([f for f in result.allFrontiers.values() if not f.empty]))) result.searchTimes.append(ensembleTimes[bestRecognizer]) if len(ensembleTimes[bestRecognizer]) > 0: eprint("Average search time: ", int(mean(ensembleTimes[bestRecognizer]) + 0.5), "sec.\tmedian:", int(median(ensembleTimes[bestRecognizer]) + 0.5), "\tmax:", int(max(ensembleTimes[bestRecognizer]) + 0.5), "\tstandard deviation", int(standardDeviation(ensembleTimes[bestRecognizer]) + 0.5)) return totalTasksHitBottomUp def consolidate(result, grammar, _=None, topK=None, arity=None, pseudoCounts=None, aic=None, structurePenalty=None, compressor=None, CPUs=None, iteration=None): eprint("Showing the top 5 programs in each frontier being sent to the compressor:") for f in result.allFrontiers.values(): if f.empty: continue eprint(f.task) for e in f.normalize().topK(5): eprint("%.02f\t%s" % (e.logPosterior, e.program)) eprint() # First check if we have supervision at the program level for any task that was not solved needToSupervise = {f.task for f in result.allFrontiers.values() if f.task.supervision is not None and f.empty} compressionFrontiers = [f.replaceWithSupervised(grammar) if f.task in needToSupervise else f for f in result.allFrontiers.values() ] if len([f for f in compressionFrontiers if not f.empty]) == 0: eprint("No compression frontiers; not inducing a grammar this iteration.") else: grammar, compressionFrontiers = induceGrammar(grammar, compressionFrontiers, topK=topK, pseudoCounts=pseudoCounts, a=arity, aic=aic, structurePenalty=structurePenalty, topk_use_only_likelihood=False, backend=compressor, CPUs=CPUs, iteration=iteration) # Store compression frontiers in the result. for c in compressionFrontiers: result.allFrontiers[c.task] = c.topK(0) if c in needToSupervise else c result.grammars.append(grammar) eprint("Grammar after iteration %d:" % (iteration + 1)) eprint(grammar) return grammar def commandlineArguments(_=None, iterations=None, enumerationTimeout=None, testEvery=1, topK=1, reuseRecognition=False, CPUs=1, solver='ocaml', compressor="ocaml", useRecognitionModel=True, recognitionTimeout=None, activation='relu', helmholtzRatio=1., featureExtractor=None, cuda=None, maximumFrontier=None, pseudoCounts=1.0, aic=1.0, structurePenalty=0.001, a=0, taskBatchSize=None, taskReranker="default", extras=None, storeTaskMetrics=False, rewriteTaskMetrics=True): if cuda is None: cuda = torch.cuda.is_available() print("CUDA is available?:", torch.cuda.is_available()) print("using cuda?:", cuda) import argparse parser = argparse.ArgumentParser(description="") parser.add_argument("--resume", help="Resumes EC algorithm from checkpoint. You can either pass in the path of a checkpoint, or you can pass in the iteration to resume from, in which case it will try to figure out the path.", default=None, type=str) parser.add_argument("-i", "--iterations", help="default: %d" % iterations, default=iterations, type=int) parser.add_argument("-t", "--enumerationTimeout", default=enumerationTimeout, help="In seconds. default: %s" % enumerationTimeout, type=int) parser.add_argument("-R", "--recognitionTimeout", default=recognitionTimeout, help="In seconds. Amount of time to train the recognition model on each iteration. Defaults to enumeration timeout.", type=int) parser.add_argument("-RS", "--recognitionSteps", default=None, help="Number of gradient steps to train the recognition model. Can be specified instead of train time.", type=int) parser.add_argument( "-k", "--topK", default=topK, help="When training generative and discriminative models, we train them to fit the top K programs. Ideally we would train them to fit the entire frontier, but this is often intractable. default: %d" % topK, type=int) parser.add_argument("-p", "--pseudoCounts", default=pseudoCounts, help="default: %f" % pseudoCounts, type=float) parser.add_argument("-b", "--aic", default=aic, help="default: %f" % aic, type=float) parser.add_argument("-l", "--structurePenalty", default=structurePenalty, help="default: %f" % structurePenalty, type=float) parser.add_argument("-a", "--arity", default=a, help="default: %d" % a, type=int) parser.add_argument("-c", "--CPUs", default=CPUs, help="default: %d" % CPUs, type=int) parser.add_argument("--no-cuda", action="store_false", dest="cuda", help="""cuda will be used if available (which it %s), unless this is set""" % ("IS" if cuda else "ISN'T")) parser.add_argument("-m", "--maximumFrontier", help="""Even though we enumerate --frontierSize programs, we might want to only keep around the very best for performance reasons. This is a cut off on the maximum size of the frontier that is kept around. Default: %s""" % maximumFrontier, type=int) parser.add_argument("--reuseRecognition", help="""Should we initialize recognition model weights to be what they were at the previous DreamCoder iteration? Default: %s""" % reuseRecognition, default=reuseRecognition, action="store_true") parser.add_argument("--recognition", dest="useRecognitionModel", action="store_true", help="""Enable bottom-up neural recognition model. Default: %s""" % useRecognitionModel) parser.add_argument("--ensembleSize", dest="ensembleSize", default=1, help="Number of recognition models to train and enumerate from at each iteration.", type=int) parser.add_argument("-g", "--no-recognition", dest="useRecognitionModel", action="store_false", help="""Disable bottom-up neural recognition model. Default: %s""" % (not useRecognitionModel)) parser.add_argument("-d", "--no-dsl", dest="useDSL", action="store_false", help="""Disable DSL enumeration and updating.""") parser.add_argument("--no-consolidation", dest="noConsolidation", action="store_true", help="""Disable DSL updating.""") parser.add_argument( "--testingTimeout", type=int, dest="testingTimeout", default=0, help="Number of seconds we should spend evaluating on each held out testing task.") parser.add_argument( "--testEvery", type=int, dest="testEvery", default=1, help="Run heldout testing every X iterations." ) parser.add_argument( "--seed", type=int, default=0, help="Random seed. Currently this only matters for random batching strategies.") parser.add_argument( "--activation", choices=[ "relu", "sigmoid", "tanh"], default=activation, help="""Activation function for neural recognition model. Default: %s""" % activation) parser.add_argument( "--solver", choices=[ "ocaml", "pypy", "python"], default=solver, help="""Solver for enumeration. Default: %s""" % solver) parser.add_argument( "-r", "--Helmholtz", dest="helmholtzRatio", help="""When training recognition models, what fraction of the training data should be samples from the generative model? Default %f""" % helmholtzRatio, default=helmholtzRatio, type=float) parser.add_argument( "--compressor", default=compressor, choices=["pypy","rust","vs","pypy_vs","ocaml","memorize"]) parser.add_argument( "--matrixRank", help="Maximum rank of bigram transition matrix for contextual recognition model. Defaults to full rank.", default=None, type=int) parser.add_argument( "--mask", help="Unconditional bigram masking", default=False, action="store_true") parser.add_argument("--biasOptimal", help="Enumerate dreams rather than sample them & bias-optimal recognition objective", default=False, action="store_true") parser.add_argument("--contextual", help="bigram recognition model (default is unigram model)", default=False, action="store_true") parser.add_argument("--clear-recognition", dest="clear-recognition", help="Clears the recognition model from a checkpoint. Necessary for graphing results with recognition models, because pickle is kind of stupid sometimes.", default=None, type=str) parser.add_argument("--primitive-graph", dest="primitive-graph", nargs='+', help="Displays a dependency graph of the learned primitives", default=None, type=str) parser.add_argument( "--taskBatchSize", dest="taskBatchSize", help="Number of tasks to train on during wake. Defaults to all tasks if None.", default=None, type=int) parser.add_argument( "--taskReranker", dest="taskReranker", help="Reranking function used to order the tasks we train on during waking.", choices=[ "default", "random", "randomShuffle", "unsolved", "unsolvedEntropy", "unsolvedRandomEntropy", "randomkNN", "randomLowEntropykNN"], default=taskReranker, type=str) parser.add_argument( "--storeTaskMetrics", dest="storeTaskMetrics", default=True, help="Whether to store task metrics directly in the ECResults.", action="store_true" ) parser.add_argument( "--rewriteTaskMetrics", dest="rewriteTaskMetrics", help="Whether to rewrite a new task metrics dictionary at each iteration, rather than retaining the old.", action="store_true" ) parser.add_argument("--addTaskMetrics", dest="addTaskMetrics", help="Creates a checkpoint with task metrics and no recognition model for graphing.", default=None, nargs='+', type=str) parser.add_argument("--auxiliary", action="store_true", default=False, help="Add auxiliary classification loss to recognition network training", dest="auxiliaryLoss") parser.add_argument("--addFullTaskMetrics", help="Only to be used in conjunction with --resume. Loads checkpoint, solves both testing and training tasks, stores frontiers, solve times, and task metrics, and then dies.", default=False, action="store_true") parser.add_argument("--countParameters", help="Load a checkpoint then report how many parameters are in the recognition model.", default=None, type=str) parser.set_defaults(useRecognitionModel=useRecognitionModel, useDSL=True, featureExtractor=featureExtractor, maximumFrontier=maximumFrontier, cuda=cuda) if extras is not None: extras(parser) v = vars(parser.parse_args()) if v["clear-recognition"] is not None: ECResult.clearRecognitionModel(v["clear-recognition"]) sys.exit(0) else: del v["clear-recognition"] if v["primitive-graph"] is not None: for n,pg in enumerate(v["primitive-graph"]): with open(pg,'rb') as handle: result = dill.load(handle) graphPrimitives(result,f"figures/deepProgramLearning/{sys.argv[0]}{n}",view=True) sys.exit(0) else: del v["primitive-graph"] if v["addTaskMetrics"] is not None: for path in v["addTaskMetrics"]: with open(path,'rb') as handle: result = dill.load(handle) addTaskMetrics(result, path) sys.exit(0) else: del v["addTaskMetrics"] if v["useRecognitionModel"] and v["recognitionTimeout"] is None: v["recognitionTimeout"] = v["enumerationTimeout"] if v["countParameters"]: with open(v["countParameters"], "rb") as handle: result = dill.load(handle) eprint("The recognition model has", sum(p.numel() for p in result.recognitionModel.parameters() if p.requires_grad), "trainable parameters and", sum(p.numel() for p in result.recognitionModel.parameters() ), "total parameters.\n", "The feature extractor accounts for", sum(p.numel() for p in result.recognitionModel.featureExtractor.parameters() ), "of those parameters.\n", "The grammar builder accounts for", sum(p.numel() for p in result.recognitionModel.grammarBuilder.parameters() ), "of those parameters.\n") sys.exit(0) del v["countParameters"] return v def addTaskMetrics(result, path): """Adds a task metrics to ECResults that were pickled without them.""" with torch.no_grad(): return addTaskMetrics_(result, path) def addTaskMetrics_(result, path): SUFFIX = '.pickle' assert path.endswith(SUFFIX) tasks = result.taskSolutions.keys() everyTask = set(tasks) for t in result.recognitionTaskMetrics: if isinstance(t, Task) and t not in everyTask: everyTask.add(t) eprint(f"Found {len(tasks)} training tasks.") eprint(f"Scrounged up {len(everyTask) - len(tasks)} testing tasks.") if not hasattr(result, "recognitionTaskMetrics") or result.recognitionTaskMetrics is None: result.recognitionTaskMetrics = {} # If task has images, store them. if hasattr(list(tasks)[0], 'getImage'): images = {t: t.getImage(pretty=True) for t in tasks} updateTaskSummaryMetrics(result.recognitionTaskMetrics, images, 'taskImages') if hasattr(list(tasks)[0], 'highresolution'): images = {t: t.highresolution for t in tasks} updateTaskSummaryMetrics(result.recognitionTaskMetrics, images, 'taskImages') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.auxiliaryPrimitiveEmbeddings(), 'auxiliaryPrimitiveEmbeddings') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskAuxiliaryLossLayer(tasks), 'taskAuxiliaryLossLayer') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskAuxiliaryLossLayer(everyTask), 'every_auxiliaryLossLayer') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarFeatureLogProductions(tasks), 'grammarFeatureLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarFeatureLogProductions(everyTask), 'every_grammarFeatureLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarLogProductions(tasks), 'contextualLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarLogProductions(everyTask), 'every_contextualLogProductions') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskHiddenStates(tasks), 'hiddenState') updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskHiddenStates(everyTask), 'every_hiddenState') g = result.grammars[-2] # the final entry in result.grammars is a grammar that we have not used yet updateTaskSummaryMetrics(result.recognitionTaskMetrics, {f.task: f.expectedProductionUses(g) for f in result.taskSolutions.values() if len(f) > 0}, 'expectedProductionUses') updateTaskSummaryMetrics(result.recognitionTaskMetrics, {f.task: f.expectedProductionUses(g) for t, metrics in result.recognitionTaskMetrics.items() if "frontier" in metrics for f in [metrics["frontier"]] if len(f) > 0}, 'every_expectedProductionUses') if False: eprint(f"About to do an expensive Monte Carlo simulation w/ {len(tasks)} tasks") updateTaskSummaryMetrics(result.recognitionTaskMetrics, {task: result.recognitionModel.grammarOfTask(task).untorch().expectedUsesMonteCarlo(task.request, debug=False) for task in tasks }, 'expectedProductionUsesMonteCarlo') try: updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarStartProductions(tasks), 'startProductions') except: pass # can fail if we do not have a contextual model #updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarLogProductions(tasks), 'task_no_parent_log_productions') #updateTaskSummaryMetrics(result.recognitionTaskMetrics, result.recognitionModel.taskGrammarEntropies(tasks), 'taskGrammarEntropies') result.recognitionModel = None clearedPath = path[:-len(SUFFIX)] + "_graph=True" + SUFFIX with open(clearedPath,'wb') as handle: result = dill.dump(result, handle) eprint(" [+] Cleared recognition model from:") eprint(" %s"%path) eprint(" and exported to:") eprint(" %s"%clearedPath) eprint(" Use this one for graphing.")