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.")