Datasets:

Fraser
/

dream-coder

	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)