from dreamcoder.dreamcoder import * from dreamcoder.domains.tower.towerPrimitives import primitives, new_primitives, animateTower from dreamcoder.domains.tower.makeTowerTasks import * from dreamcoder.domains.tower.tower_common import renderPlan, towerLength, centerTower from dreamcoder.utilities import * import os import datetime try: #pypy will fail from dreamcoder.recognition import variable import torch.nn as nn import torch.nn.functional as F class Flatten(nn.Module): def __init__(self): super(Flatten, self).__init__() def forward(self, x): return x.view(x.size(0), -1) class TowerCNN(nn.Module): special = 'tower' def __init__(self, tasks, testingTasks=[], cuda=False, H=64): super(TowerCNN, self).__init__() self.CUDA = cuda self.recomputeTasks = True self.outputDimensionality = H def conv_block(in_channels, out_channels): return nn.Sequential( nn.Conv2d(in_channels, out_channels, 3, padding=1), # nn.BatchNorm2d(out_channels), nn.ReLU(), nn.MaxPool2d(2) ) self.inputImageDimension = 256 self.resizedDimension = 64 assert self.inputImageDimension % self.resizedDimension == 0 # channels for hidden hid_dim = 64 z_dim = 64 self.encoder = nn.Sequential( conv_block(6, hid_dim), conv_block(hid_dim, hid_dim), conv_block(hid_dim, hid_dim), conv_block(hid_dim, z_dim), Flatten() ) self.outputDimensionality = 1024 if cuda: self.CUDA=True self.cuda() # I think this should work? def forward(self, v, v2=None): """v: tower to build. v2: image of tower we have built so far""" # insert batch if it is not already there if len(v.shape) == 3: v = np.expand_dims(v, 0) inserted_batch = True if v2 is not None: assert len(v2.shape) == 3 v2 = np.expand_dims(v2, 0) elif len(v.shape) == 4: inserted_batch = False pass else: assert False, "v has the shape %s"%(str(v.shape)) if v2 is None: v2 = np.zeros(v.shape) v = np.concatenate((v,v2), axis=3) v = np.transpose(v,(0,3,1,2)) assert v.shape == (v.shape[0], 6,self.inputImageDimension,self.inputImageDimension) v = variable(v, cuda=self.CUDA).float() window = int(self.inputImageDimension/self.resizedDimension) v = F.avg_pool2d(v, (window,window)) #showArrayAsImage(np.transpose(v.data.numpy()[0,:3,:,:],[1,2,0])) v = self.encoder(v) if inserted_batch: return v.view(-1) else: return v def featuresOfTask(self, t, t2=None): # Take a task and returns [features] return self(t.getImage(), None if t2 is None else t2.getImage(drawHand=True)) def featuresOfTasks(self, ts, t2=None): # Take a task and returns [features] """Takes the goal first; optionally also takes the current state second""" if t2 is None: pass elif isinstance(t2, Task): assert False #t2 = np.array([t2.getImage(drawHand=True)]*len(ts)) elif isinstance(t2, list): t2 = np.array([t.getImage(drawHand=True) if t else np.zeros((self.inputImageDimension, self.inputImageDimension, 3)) for t in t2]) else: assert False return self(np.array([t.getImage() for t in ts]), t2) def taskOfProgram(self, p, t, lenient=False): try: pl = executeTower(p,0.05) if pl is None or (not lenient and len(pl) == 0): return None if len(pl) > 100 or towerLength(pl) > 360: return None t = SupervisedTower("tower dream", p) return t except Exception as e: return None except: pass def tower_options(parser): parser.add_argument("--tasks", choices=["old","new"], default="old") parser.add_argument("--visualize", default=None, type=str) parser.add_argument("--solutions", default=None, type=str) parser.add_argument("--split", default=1., type=float) parser.add_argument("--dream", default=None, type=str) parser.add_argument("--primitives", default="old", type=str, choices=["new", "old"]) def dreamOfTowers(grammar, prefix, N=250, make_montage=True): request = arrow(ttower,ttower) randomTowers = [tuple(centerTower(t)) for _ in range(N) for program in [grammar.sample(request, maximumDepth=12, maxAttempts=100)] if program is not None for t in [executeTower(program, timeout=0.5) or []] if len(t) >= 1 and len(t) < 100 and towerLength(t) <= 360.] matrix = [renderPlan(p,Lego=True,pretty=True) for p in randomTowers] # Only visualize if it has something to visualize. if len(matrix) > 0: import scipy.misc if make_montage: matrix = montage(matrix) scipy.misc.imsave('%s.png'%prefix, matrix) else: for n,i in enumerate(matrix): scipy.misc.imsave(f'{prefix}/{n}.png', i) else: eprint("Tried to visualize dreams, but none to visualize.") def visualizePrimitives(primitives, fn=None): from itertools import product #from pylab import imshow,show from dreamcoder.domains.tower.towerPrimitives import _left,_right,_loop,_embed,_empty_tower,TowerState _13 = Program.parse("1x3").value _31 = Program.parse("3x1").value r = lambda n,k: _right(2*n)(k) l = lambda n,k: _left(2*n)(k) _e = _embed _lp = lambda n,b,k: _loop(n)(b)(k) _arch = lambda k: l(1,_13(r(2,_13(l(1,_31(k)))))) _tallArch = lambda h,z,k: _lp(h, lambda _: _13(r(2,_13(l(2,z)))), r(1,_31(k))) matrix = [] for p in primitives: if not p.isInvented: continue eprint(p,":",p.tp) t = p.tp if t.returns() != ttower: continue def argumentChoices(t): if t == ttower: return [_empty_tower] elif t == tint: return list(range(5)) elif t == arrow(ttower,ttower): return [_arch,_13,_31] else: return [] ts = [] for arguments in product(*[argumentChoices(t) for t in t.functionArguments() ]): t = p.evaluate([]) for a in arguments: t = t(a) t = t(TowerState())[1] ts.append(t) if ts == []: continue matrix.append([renderPlan(p,pretty=True) for p in ts]) # Only visualize if it has something to visualize. if len(matrix) > 0: matrix = montageMatrix(matrix) # imshow(matrix) import scipy.misc scipy.misc.imsave(fn, matrix) # show() else: eprint("Tried to visualize primitives, but none to visualize.") def animateSolutions(checkpoint): with open(checkpoint,"rb") as handle: result = dill.load(handle) for n,f in enumerate(result.taskSolutions.values()): animateTower(f"/tmp/tower_animation_{n}",f.bestPosterior.program) def visualizeSolutions(solutions, export, tasks=None): if tasks is None: tasks = list(solutions.keys()) tasks.sort(key=lambda t: len(t.plan)) matrix = [] for t in tasks: i = renderPlan(centerTower(t.plan),pretty=True,Lego=True) if solutions[t].empty: i = i/3. matrix.append(i) # Only visualize if it has something to visualize. if len(matrix) > 0: matrix = montage(matrix) import scipy.misc scipy.misc.imsave(export, matrix) else: eprint("Tried to visualize solutions, but none to visualize.") def main(arguments): """ Takes the return value of the `commandlineArguments()` function as input and trains/tests the model on a set of tower-building tasks. """ # The below global statement is required since primitives is modified within main(). # TODO(lcary): use a function call to retrieve and declare primitives instead. global primitives import scipy.misc g0 = Grammar.uniform({"new": new_primitives, "old": primitives}[arguments.pop("primitives")], continuationType=ttower) checkpoint = arguments.pop("visualize") if checkpoint is not None: with open(checkpoint,'rb') as handle: primitives = pickle.load(handle).grammars[-1].primitives visualizePrimitives(primitives) sys.exit(0) checkpoint = arguments.pop("solutions") if checkpoint is not None: with open(checkpoint,'rb') as handle: solutions = pickle.load(handle).taskSolutions visualizeSolutions(solutions, checkpoint + ".solutions.png") animateSolutions(checkpoint) sys.exit(0) checkpoint = arguments.pop("dream") if checkpoint is not None: with open(checkpoint,'rb') as handle: g = pickle.load(handle).grammars[-1] os.system("mkdir -p data/tower_dreams") dreamOfTowers(g, "data/tower_dreams", make_montage=False) sys.exit(0) tasks = arguments.pop("tasks") if tasks == "new": tasks = makeSupervisedTasks() elif tasks == "old": tasks = makeOldSupervisedTasks() else: assert False test, train = testTrainSplit(tasks, arguments.pop("split")) eprint("Split %d/%d test/train" % (len(test), len(train))) # Make a montage for the paper shuffledTrain = list(train) shuffledTest = list(test) random.shuffle(shuffledTrain) shuffledTrain = shuffledTrain + [None]*(60 - len(shuffledTrain)) random.shuffle(shuffledTest) shuffledTest = shuffledTest + [None]*(60 - len(shuffledTest)) try: SupervisedTower.exportMany("/tmp/every_tower.png",shuffledTrain + shuffledTest, shuffle=False, columns=10) for j,task in enumerate(tasks): task.exportImage(f"/tmp/tower_task_{j}.png") for k,v in dSLDemo().items(): scipy.misc.imsave(f"/tmp/tower_dsl_{k}.png", v) os.system(f"convert /tmp/tower_dsl_{k}.png -channel RGB -negate /tmp/tower_dsl_{k}.png") except: eprint("WARNING: can't export images. scipy needs to be an older version") timestamp = datetime.datetime.now().isoformat() outputDirectory = "experimentOutputs/towers/%s"%timestamp os.system("mkdir -p %s"%outputDirectory) os.system("mkdir -p data/tower_dreams_initial") try: dreamOfTowers(g0, "data/tower_dreams_initial", make_montage=False) dreamOfTowers(g0, "%s/random_0"%outputDirectory) except: eprint("WARNING: can't export images. scipy needs to be an older version") evaluationTimeout = 0.005 generator = ecIterator(g0, train, testingTasks=test, outputPrefix="%s/tower"%outputDirectory, evaluationTimeout=evaluationTimeout, **arguments) for result in generator: continue iteration = len(result.learningCurve) newTowers = [tuple(centerTower(executeTower(frontier.sample().program))) for frontier in result.taskSolutions.values() if not frontier.empty] try: fn = '%s/solutions_%d.png'%(outputDirectory,iteration) visualizeSolutions(result.taskSolutions, fn, train) eprint("Exported solutions to %s\n"%fn) dreamOfTowers(result.grammars[-1], '%s/random_%d'%(outputDirectory,iteration)) except ImportError: eprint("Could not import required libraries for exporting towers.") primitiveFilename = '%s/primitives_%d.png'%(outputDirectory, iteration) visualizePrimitives(result.grammars[-1].primitives, primitiveFilename) eprint("Exported primitives to",primitiveFilename)