dreamcoder/domains/text/main.py

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