tasks=tasks, bidirectional=True) if __name__ == "__main__": tasks = makeTasks() eprint("Generated", len(tasks), "tasks") test, train = testTrainSplit(tasks, 0.2) eprint("Split tasks into %d/%d test/train" % (len(test), len(train))) baseGrammar = Grammar.uniform(primitives) explorationCompression(baseGrammar, train, testingTasks=test, outputPrefix="experimentOutputs/text", evaluationTimeout=0.0005, **commandlineArguments( steps=500, iterations=10, helmholtzRatio=0.5, topK=2, maximumFrontier=2, structurePenalty=10., a=3, activation="relu", CPUs=numberOfCPUs(), featureExtractor=LearnedFeatureExtractor, pseudoCounts=10.0))
def rational_options(p): p.add_argument("--smooth", action="store_true", default=False, help="smooth likelihood model") if __name__ == "__main__": import time arguments = commandlineArguments(featureExtractor=FeatureExtractor, iterations=6, CPUs=numberOfCPUs(), structurePenalty=1., recognitionTimeout=7200, helmholtzRatio=0.5, activation="tanh", maximumFrontier=5, a=3, topK=2, pseudoCounts=30.0, extras=rational_options) primitives = [ real, # f1, real_division, real_addition, real_multiplication ] baseGrammar = Grammar.uniform(primitives) random.seed(42)
f.close() self.mean = [] if __name__ == "__main__": tasks = makeTasks() eprint("Generated", len(tasks), "tasks") test, train = testTrainSplit(tasks, 0.5) eprint("Split tasks into %d/%d test/train" % (len(test), len(train))) baseGrammar = Grammar.uniform(primitives) explorationCompression(baseGrammar, train, testingTasks=test, outputPrefix="experimentOutputs/geom", compressor="rust", evaluationTimeout=0.01, **commandlineArguments( steps=200, a=1, iterations=100, useRecognitionModel=True, helmholtzRatio=0.5, helmholtzBatch=200, featureExtractor=GeomFeatureCNN, topK=2, maximumFrontier=1000, CPUs=numberOfCPUs(), pseudoCounts=10.0))
parser.add_argument("--split", metavar="TRAIN_RATIO", type=float, help="split test/train") parser.add_argument("-H", "--hidden", type=int, default=16, help="number of hidden units") parser.add_argument("--filter_task_args", default=False, action="store_true", help="only use tasks with 1 arguments") if __name__ == "__main__": args = commandlineArguments( frontierSize=None, activation='sigmoid', iterations=10, a=3, maximumFrontier=10, topK=2, pseudoCounts=10.0, helmholtzRatio=0.5, structurePenalty=1., CPUs=numberOfCPUs(), extras=list_options) tasks = retrieveTasks(args.pop("dataset")) #removing f****d up tasks # tasks = [ t for t in tasks #if tasks.request == 1] maxTasks = args.pop("maxTasks") if len(tasks) > maxTasks:
fn = "/tmp/logo_primitive_%d.png" % len(matrix) eprint("\tExported to", fn) scipy.misc.imsave(fn, r) matrix = montageMatrix(matrix) scipy.misc.imsave(export, matrix) if __name__ == "__main__": args = commandlineArguments(structurePenalty=1.5, recognitionTimeout=3600, a=3, topK=2, iterations=10, useRecognitionModel=True, helmholtzRatio=0.5, featureExtractor=LogoFeatureCNN, maximumFrontier=5, CPUs=numberOfCPUs(), pseudoCounts=30.0, activation="tanh", extras=list_options) visualizeCheckpoint = args.pop("visualize") if visualizeCheckpoint is not None: with open(visualizeCheckpoint, 'rb') as handle: primitives = pickle.load(handle).grammars[-1].primitives visualizePrimitives(primitives) import sys sys.exit(0) dreamCheckpoint = args.pop("dreamCheckpoint")
) parser.add_argument("--random-seed", type=int, default=0 ) parser.add_argument("--checkpoint-analysis", default=None, type=str) if __name__ == "__main__": # EC command line arguments. args = commandlineArguments( enumerationTimeout=10, activation='tanh', iterations=1, recognitionTimeout=3600, a=3, maximumFrontier=10, topK=2, pseudoCounts=30.0, helmholtzRatio=0.5, structurePenalty=1., CPUs=numberOfCPUs(), featureExtractor=InstructionsFeatureExtractor, extras=puddleworld_options) checkpoint_analysis = args.pop("checkpoint_analysis") # EC checkpoints need to be run out of their calling files, so this is here. """Run the EC learner.""" if checkpoint_analysis is None: # Set up output directories. random.seed(args.pop("random_seed")) timestamp = datetime.datetime.now().isoformat() outputDirectory = "experimentOutputs/puddleworld/%s"%timestamp os.system("mkdir -p %s"%outputDirectory)
while len(circuits) < NUMBEROFTASKS * 2: inputs = sampleDistribution(inputDistribution) gates = sampleDistribution(gateDistribution) newTask = Circuit(numberOfInputs=inputs, numberOfGates=gates) if newTask not in circuits: circuits.append(newTask) eprint("Sampled %d circuits with %d unique functions" % (len(circuits), len({t.signature for t in circuits}))) tasks = [t.task() for t in circuits[:NUMBEROFTASKS]] testing = [t.task() for t in circuits[NUMBEROFTASKS:]] baseGrammar = Grammar.uniform(primitives) explorationCompression(baseGrammar, tasks, testingTasks=testing, outputPrefix="experimentOutputs/circuit", evaluationTimeout=None, **commandlineArguments( iterations=10, aic=1., structurePenalty=1, CPUs=numberOfCPUs(), featureExtractor=DeepFeatureExtractor, topK=2, maximumFrontier=100, helmholtzRatio=0.5, a=2, activation="relu", pseudoCounts=5.))
S=5), makeTask("series capacitors", arrow(tlist(tpositive), tpositive), lambda cs: sum(c**(-1) for c in cs)**(-1), N=20, S=5), ] if __name__ == "__main__": baseGrammar = Grammar.uniform([ real, f0, f1, fpi, real_power, real_subtraction, real_addition, real_multiplication ]) eprint("Got %d equation discovery tasks..." % len(tasks)) explorationCompression(baseGrammar, tasks, outputPrefix="experimentOutputs/scientificLaws", evaluationTimeout=0.1, testingTasks=[], **commandlineArguments(iterations=10, CPUs=numberOfCPUs(), structurePenalty=1., helmholtzRatio=0.5, a=3, maximumFrontier=10000, topK=2, featureExtractor=None, pseudoCounts=10.0))
return e def invented(self, e): return e.body.visit(self) def abstraction(self, e): return Abstraction(e.body.visit(self)) def application(self, e): return Application(e.f.visit(self), e.x.visit(self)) def index(self, e): return e RandomParameterization.single = RandomParameterization() if __name__ == "__main__": baseGrammar = Grammar.uniform(primitives) statistics = Task.standardizeTasks(tasks) featureExtractor = makeFeatureExtractor(statistics) explorationCompression( baseGrammar, tasks, outputPrefix="experimentOutputs/continuousPolynomial", **commandlineArguments(frontierSize=10**2, iterations=5, featureExtractor=featureExtractor, pseudoCounts=10.0))
for t in train: l = t.logLikelihood(e) eprint(t, l) biggest = min(biggest,l) eprint(biggest) assert False if False: with timing("best first enumeration"): baseGrammar.bestFirstEnumeration(arrow(tint,tint)) with timing("depth first search"): print len(list(enumeration(baseGrammar, Context.EMPTY, [], arrow(tint,tint), maximumDepth = 99, upperBound = 13, lowerBound = 0))) assert False explorationCompression(baseGrammar, train, outputPrefix = "experimentOutputs/regression", evaluationTimeout = None, testingTasks = test, **commandlineArguments(frontierSize = 10**2, iterations = 10, CPUs = numberOfCPUs(), structurePenalty = 1., helmholtzRatio = 0.5, a = 1,#arity maximumFrontier = 1000, topK = 2, featureExtractor = DeepFeatureExtractor, pseudoCounts = 10.0))
"--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." ) if __name__ == "__main__": arguments = commandlineArguments(recognitionTimeout=7200, iterations=10, helmholtzRatio=0.5, topK=2, maximumFrontier=5, structurePenalty=10., a=3, activation="tanh", CPUs=numberOfCPUs(), featureExtractor=LearnedFeatureExtractor, pseudoCounts=30.0, extras=text_options) doChallenge = arguments.pop('doChallenge') 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)))
f1, fpi, real_power, real_subtraction, real_addition, real_division, real_multiplication] + [ Program.parse(n) for n in ["map","fold", "empty","cons","car","cdr", "zip"]] baseGrammar = Grammar.uniform(equationPrimitives) eprint("Got %d equation discovery tasks..." % len(tasks)) explorationCompression(baseGrammar, tasks, outputPrefix="experimentOutputs/scientificLaws", evaluationTimeout=0.1, testingTasks=[], **commandlineArguments( compressor="ocaml", featureExtractor=DummyFeatureExtractor, iterations=10, CPUs=numberOfCPUs(), structurePenalty=0.5, helmholtzRatio=0.5, a=3, maximumFrontier=10000, topK=2, pseudoCounts=10.0))