from dreamcoder.dreamcoder import ecIterator
from dreamcoder.domains.text.makeTextTasks import makeTasks, loadPBETasks
from dreamcoder.domains.text.textPrimitives import primitives
from dreamcoder.domains.list.listPrimitives import bootstrapTarget
from dreamcoder.enumeration import *
import os
import datetime
import random
from functools import reduce
import dill
class ConstantInstantiateVisitor(object):
def __init__(self, words):
self.words = words
def primitive(self, e):
if e.name == "STRING":
return Primitive("STRING", e.tp, random.choice(self.words))
return e
def invented(self, e): return e.body.visit(self)
def index(self, e): return e
def application(self, e):
return Application(e.f.visit(self), e.x.visit(self))
def abstraction(self, e):
return Abstraction(e.body.visit(self))
try:
from dreamcoder.recognition import *
class LearnedFeatureExtractor(RecurrentFeatureExtractor):
special = 'string'
def tokenize(self, examples):
def tokenize_example(xs,y):
if not isinstance(y, list): y = [y]
return xs,y
return [tokenize_example(*e) for e in examples]
def __init__(self, tasks, testingTasks=[], cuda=False):
lexicon = {c
for t in tasks + testingTasks
for xs, y in self.tokenize(t.examples)
for c in reduce(lambda u, v: u + v, list(xs) + [y])}
self.recomputeTasks = True
super(LearnedFeatureExtractor, self).__init__(lexicon=list(lexicon),
H=64,
tasks=tasks,
bidirectional=True,
cuda=cuda)
self.MAXINPUTS = 8
def taskOfProgram(self, p, tp):
# Instantiate STRING w/ random words
p = p.visit(ConstantInstantiateVisitor.SINGLE)
return super(LearnedFeatureExtractor, self).taskOfProgram(p, tp)
except:
pass
### COMPETITION CODE
def competeOnOneTask(checkpoint, task,
CPUs=8, timeout=3600, evaluationTimeout=0.0005):
if checkpoint.recognitionModel is not None:
recognizer = checkpoint.recognitionModel
challengeFrontiers, times, bestSearchTime = \
recognizer.enumerateFrontiers([task],
CPUs=CPUs,
maximumFrontier=1,
enumerationTimeout=timeout,
evaluationTimeout=evaluationTimeout)
else:
challengeFrontiers, times, bestSearchTimes = \
multicoreEnumeration(checkpoint.grammars[-1], [task],
CPUs=CPUs,
maximumFrontier=1,
enumerationTimeout=timeout,
evaluationTimeout=evaluationTimeout)
if len(times) == 0: return None, task
assert len(times) == 1
return times[0], task
def sygusCompetition(checkpoints, tasks):
from pathos.multiprocessing import Pool
import datetime
# map from task to list of search times, one for each checkpoint.
# search time will be None if it is not solved
searchTimes = {t: [] for t in tasks}
CPUs = int(8/len(checkpoints))
maxWorkers = int(numberOfCPUs()/CPUs)
workers = Pool(maxWorkers)
eprint(f"You gave me {len(checkpoints)} checkpoints to ensemble. Each checkpoint will get {CPUs} CPUs. Creating a pool of {maxWorkers} worker processes.")
timeout = 3600
promises = []
for t in tasks:
for checkpoint in checkpoints:
promise = workers.apply_async(competeOnOneTask,
(checkpoint,t),
{"CPUs": CPUs,
"timeout": timeout})
promises.append(promise)
eprint(f"Queued {len(promises)} jobs.")
for promise in promises:
dt, task = promise.get()
if dt is not None:
searchTimes[task].append(dt)
searchTimes = {t: min(ts) if len(ts) > 0 else None
for t,ts in searchTimes.items()}
fn = "experimentOutputs/text_competition_%s.p"%(datetime.datetime.now().isoformat())
with open(fn,"wb") as handle:
pickle.dump(searchTimes, handle)
eprint()
hits = sum( t is not None for t in searchTimes.values() )
total = len(searchTimes)
percentage = 100*hits/total
eprint("Hits %d/%d = %f\n"%(hits, total, percentage))
eprint()
eprint("Exported competition results to",fn)
def text_options(parser):
parser.add_argument(
"--showTasks",
action="store_true",
default=False,
help="show the training test and challenge tasks and then exit")
parser.add_argument(
"--trainChallenge",
action="store_true",
default=False,
help="Incorporate a random 50% of the challenge problems into the training set")
parser.add_argument(
"--onlyChallenge",
action="store_true",
default=False,
help="Only train on challenge problems and have testing problems.")
parser.add_argument(
"--latest",
action="store_true",
default=False,
help="evaluate on latest sygus problems rather than problems used in ec2 paper")
parser.add_argument(
"--noMap", action="store_true", default=False,
help="Disable built-in map primitive")
parser.add_argument(
"--noLength", action="store_true", default=False,
help="Disable built-in length primitive")
parser.add_argument(
"--noUnfold", action="store_true", default=False,
help="Disable built-in unfold primitive")
parser.add_argument(
"--compete",
nargs='+',
default=None,
type=str,
help="Do a simulated sygus competition (1hr+8cpus/problem) on the sygus tasks, restoring from provided checkpoint(s). If multiple checkpoints are provided, then we ensemble the models.")
def main(arguments):
"""
Takes the return value of the `commandlineArguments()` function as input and
trains/tests the model on manipulating sequences of text.
"""
tasks = makeTasks()
eprint("Generated", len(tasks), "tasks")
for t in tasks:
t.mustTrain = False
test, train = testTrainSplit(tasks, 1.)
eprint("Split tasks into %d/%d test/train" % (len(test), len(train)))
latest = arguments.pop("latest")
challenge, challengeCheating = loadPBETasks("data/sygus" if latest else "PBE_Strings_Track")
eprint("Got %d challenge PBE tasks" % len(challenge))
if arguments.pop('trainChallenge'):
challengeTest, challengeTrain = testTrainSplit(challenge, 0.5)
challenge = challengeTest
train += challengeTrain
eprint(
"Incorporating %d (50%%) challenge problems into the training set." %
(len(challengeTrain)),
"We will evaluate on the held out challenge problems.",
"This makes a total of %d training problems." %
len(train))
if arguments.pop('onlyChallenge'):
train = challenge
test = []
challenge = []
eprint("Training only on sygus problems.")
ConstantInstantiateVisitor.SINGLE = \
ConstantInstantiateVisitor(list(map(list, list({tuple([c for c in s])
for t in test + train + challenge
for s in t.stringConstants}))))
haveLength = not arguments.pop("noLength")
haveMap = not arguments.pop("noMap")
haveUnfold = not arguments.pop("noUnfold")
eprint(f"Including map as a primitive? {haveMap}")
eprint(f"Including length as a primitive? {haveLength}")
eprint(f"Including unfold as a primitive? {haveUnfold}")
baseGrammar = Grammar.uniform(primitives + [p
for p in bootstrapTarget()
if (p.name != "map" or haveMap) and \
(p.name != "unfold" or haveUnfold) and \
(p.name != "length" or haveLength)])
challengeGrammar = baseGrammar # Grammar.uniform(targetTextPrimitives)
evaluationTimeout = 0.0005
# We will spend 10 minutes on each challenge problem
challengeTimeout = 10 * 60
for t in train + test + challenge:
t.maxParameters = 2
if arguments.pop("showTasks"):
for source, ts in [("train",tasks),("test",test),("challenge",challenge)]:
print(source,"tasks:")
for t in ts:
print(t.name)
for xs, y in t.examples:
xs = ['"' + "".join(x) + '"' for x in xs]
y = "".join(y) if isinstance(y,list) else y
print('f(%s) = "%s"' % (", ".join(xs), y))
print("\t{%s}" % (t.stringConstants))
print()
sys.exit(0)
competitionCheckpoints = arguments.pop("compete")
if competitionCheckpoints:
checkpoints = []
for competitionCheckpoint in competitionCheckpoints:
with open(competitionCheckpoint, 'rb') as handle:
checkpoints.append(dill.load(handle))
sygusCompetition(checkpoints, challenge)
sys.exit(0)
timestamp = datetime.datetime.now().isoformat()
outputDirectory = "experimentOutputs/text/%s"%timestamp
os.system("mkdir -p %s"%outputDirectory)
generator = ecIterator(baseGrammar, train,
testingTasks=test + challenge,
outputPrefix="%s/text"%outputDirectory,
evaluationTimeout=evaluationTimeout,
**arguments)
for result in generator:
pass