|
from dreamcoder.domains.tower.towerPrimitives import ttower, executeTower, _empty_tower, TowerState |
|
from dreamcoder.domains.tower.tower_common import renderPlan |
|
from dreamcoder.task import * |
|
|
|
|
|
class SupervisedTower(Task): |
|
def __init__(self, name, program, mustTrain=False): |
|
if isinstance(program,str): |
|
try: |
|
program = parseTower(program) |
|
except: |
|
eprint("Parse failure:") |
|
eprint(program) |
|
assert False |
|
self.original = program |
|
plan = executeTower(program) |
|
elif isinstance(program,Program): |
|
self.original = program |
|
plan = executeTower(program) |
|
else: |
|
plan = program |
|
self.original = program |
|
state, self.plan = program.evaluate([])(_empty_tower)(TowerState()) |
|
self.hand = state.hand |
|
super(SupervisedTower, self).__init__(name, arrow(ttower,ttower), [], |
|
features=[]) |
|
self.specialTask = ("supervisedTower", |
|
{"plan": self.plan}) |
|
self.image = None |
|
self.handImage = None |
|
self.mustTrain = mustTrain |
|
|
|
def getImage(self, drawHand=False, pretty=False): |
|
if not drawHand: |
|
if not pretty: |
|
if self.image is not None: return self.image |
|
self.image = renderPlan(self.plan, pretty=pretty) |
|
return self.image |
|
else: |
|
return renderPlan(self.plan, pretty=True) |
|
else: |
|
if self.handImage is not None: return self.handImage |
|
self.handImage = renderPlan(self.plan, |
|
drawHand=self.hand, |
|
pretty=pretty) |
|
return self.handImage |
|
|
|
|
|
|
|
|
|
def __getstate__(self): |
|
return self.specialTask, self.plan, self.request, self.cache, self.name, self.examples |
|
def __setstate__(self, state): |
|
self.specialTask, self.plan, self.request, self.cache, self.name, self.examples = state |
|
self.image = None |
|
|
|
|
|
def animate(self): |
|
from pylab import imshow,show |
|
a = renderPlan(self.plan) |
|
imshow(a) |
|
show() |
|
|
|
@staticmethod |
|
def showMany(ts): |
|
from pylab import imshow,show |
|
a = montage([renderPlan(t.plan, pretty=True, Lego=True, resolution=256, |
|
drawHand=False) |
|
for t in ts]) |
|
imshow(a) |
|
show() |
|
|
|
@staticmethod |
|
def exportMany(f, ts, shuffle=True, columns=None): |
|
import numpy as np |
|
|
|
ts = list(ts) |
|
if shuffle: |
|
assert all( t is not None for t in ts ) |
|
random.shuffle(ts) |
|
a = montage([renderPlan(t.plan, pretty=True, Lego=True, resolution=256) if t is not None \ |
|
else np.zeros((256,256,3)) |
|
for t in ts], |
|
columns=columns) |
|
import scipy.misc |
|
scipy.misc.imsave(f, a) |
|
|
|
|
|
def exportImage(self, f, pretty=True, Lego=True, drawHand=False): |
|
a = renderPlan(self.plan, |
|
pretty=pretty, Lego=Lego, |
|
drawHand=t.hand if drawHand else None) |
|
import scipy.misc |
|
scipy.misc.imsave(f, a) |
|
|
|
def logLikelihood(self, e, timeout=None): |
|
from dreamcoder.domains.tower.tower_common import centerTower |
|
yh = executeTower(e, timeout) |
|
if yh is not None and centerTower(yh) == centerTower(self.plan): return 0. |
|
return NEGATIVEINFINITY |
|
|
|
|
|
|
|
def parseTower(s): |
|
_13 = Program.parse("1x3") |
|
_31 = Program.parse("3x1") |
|
_r = Program.parse("right") |
|
_l = Program.parse("left") |
|
_addition = Program.parse("+") |
|
_subtraction = Program.parse("-") |
|
_lp = Program.parse("tower_loopM") |
|
_e = Program.parse("tower_embed") |
|
|
|
from sexpdata import loads, Symbol |
|
s = loads(s) |
|
def command(k, environment, continuation): |
|
if k == Symbol("1x3") or k == Symbol("v"): return Application(_13, continuation) |
|
if k == Symbol("3x1") or k == Symbol("h"): return Application(_31, continuation) |
|
assert isinstance(k,list) |
|
if k[0] == Symbol("r"): return Application(Application(_r, expression(k[1],environment)),continuation) |
|
if k[0] == Symbol("l"): return Application(Application(_l, expression(k[1],environment)),continuation) |
|
if k[0] == Symbol("for"): |
|
v = k[1] |
|
b = expression(k[2], environment) |
|
newEnvironment = [None, v] + environment |
|
body = block(k[3:], newEnvironment, Index(0)) |
|
return Application(Application(Application(_lp,b), |
|
Abstraction(Abstraction(body))), |
|
continuation) |
|
if k[0] == Symbol("embed"): |
|
body = block(k[1:], [None] + environment, Index(0)) |
|
return Application(Application(_e,Abstraction(body)),continuation) |
|
|
|
assert False |
|
def expression(e, environment): |
|
for n, v in enumerate(environment): |
|
if e == v: return Index(n) |
|
|
|
if isinstance(e,int): return Program.parse(str(e)) |
|
|
|
assert isinstance(e,list) |
|
if e[0] == Symbol('+'): return Application(Application(_addition, expression(e[1], environment)), |
|
expression(e[2], environment)) |
|
if e[0] == Symbol('-'): return Application(Application(_subtraction, expression(e[1], environment)), |
|
expression(e[2], environment)) |
|
assert False |
|
|
|
def block(b, environment, continuation): |
|
if len(b) == 0: return continuation |
|
return command(b[0], environment, block(b[1:], environment, continuation)) |
|
|
|
try: return Abstraction(command(s, [], Index(0))) |
|
except: return Abstraction(block(s, [], Index(0))) |
|
|
|
|
|
def makeSupervisedTasks(): |
|
arches = [SupervisedTower("arch leg %d"%n, |
|
"((for i %d v) (r 4) (for i %d v) (l 2) h)"%(n,n)) |
|
for n in range(1,9) |
|
] |
|
archesStacks = [SupervisedTower("arch stack %d"%n, |
|
""" |
|
(for i %d |
|
v (r 4) v (l 2) h (l 2)) |
|
"""%n) |
|
for n in range(3,7) ] |
|
Bridges = [SupervisedTower("bridge (%d) of arch %d"%(n,l), |
|
""" |
|
(for j %d |
|
(for i %d |
|
v (r 4) v (l 4)) (r 2) h |
|
(r 4)) |
|
"""%(n,l)) |
|
for n in range(2,8) |
|
for l in range(1,6)] |
|
offsetArches = [SupervisedTower("bridge (%d) of arch, spaced %d"%(n,l), |
|
""" |
|
(for j %d |
|
(embed v (r 4) v (l 2) h ) |
|
(r %d)) |
|
"""%(n,l), |
|
mustTrain=n == 3) |
|
for n,l in [(3,7),(4,8)]] |
|
Josh = [SupervisedTower("Josh (%d)"%n, |
|
"""(for i %d |
|
h (l 2) v (r 2) v (r 2) v (l 2) h (r 6))"""%n) |
|
for n in range(1,7) ] |
|
|
|
staircase1 = [SupervisedTower("R staircase %d"%n, |
|
""" |
|
(for i %d (for j i |
|
(embed v (r 4) v (l 2) h)) (r 6)) |
|
"""%(n)) |
|
for n in range(3,8) ] |
|
staircase2 = [SupervisedTower("L staircase %d"%n, |
|
""" |
|
(for i %d (for j i |
|
(embed v (r 4) v (l 2) h)) (l 6)) |
|
"""%(n)) |
|
for n in range(3,8) ] |
|
simpleLoops = [SupervisedTower("%s row %d, spacing %d"%(o,n,s), |
|
"""(for j %d %s (r %s))"""%(n,o,s), |
|
mustTrain=True) |
|
for o,n,s in [('h',4,7), ('v',5,3)] ] |
|
|
|
pyramids = [] |
|
pyramids += [SupervisedTower("arch pyramid %d"%n, |
|
"""((for i %d (for j i (embed v (r 4) v (l 2) h)) (r 6)) |
|
(for i %d (for j (- %d i) (embed v (r 4) v (l 2) h)) (r 6)))"""%(n,n,n)) |
|
for n in range(2,6) ] |
|
pyramids += [SupervisedTower("H pyramid %d"%n, |
|
"""((for i %d (for j i h) (r 6)) |
|
(for i %d (for j (- %d i) h) (r 6)))"""%(n,n,n)) |
|
for n in range(4,6) ] |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pyramids += [SupervisedTower("H 1/2 pyramid %d"%n, |
|
""" |
|
(for i %d |
|
(r 6) |
|
(embed |
|
(for j i h (l 3)))) |
|
"""%n) |
|
for n in range(4,8) ] |
|
pyramids += [SupervisedTower("arch 1/2 pyramid %d"%n, |
|
""" |
|
(for i %d |
|
(r 6) |
|
(embed |
|
(for j i (embed v (r 4) v (l 2) h) (l 3)))) |
|
"""%n) |
|
for n in range(2,8) ] |
|
if False: |
|
pyramids += [SupervisedTower("V 1/2 pyramid %d"%n, |
|
""" |
|
(for i %d |
|
(r 2) |
|
(embed |
|
(for j i v (l 1))))"""%(n)) |
|
for n in range(4,8) ] |
|
bricks = [SupervisedTower("brickwall, %dx%d"%(w,h), |
|
"""(for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6))))"""%(h,w,w)) |
|
for w in range(3,7) |
|
for h in range(1,6) ] |
|
aqueducts = [SupervisedTower("aqueduct: %dx%d"%(w,h), |
|
"""(for j %d |
|
%s (r 4) %s (l 2) h (l 2) v (r 4) v (l 2) h (r 4))"""% |
|
(w, "v "*h, "v "*h)) |
|
for w in range(4,8) |
|
for h in range(3,6) |
|
] |
|
|
|
compositions = [SupervisedTower("%dx%d-bridge on top of %dx%d bricks"%(b1,b2,w1,w2), |
|
""" |
|
((for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6)))) |
|
(r 1) |
|
(for j %d |
|
(for i %d |
|
v (r 4) v (l 4)) (r 2) h |
|
(r 4))) |
|
"""%(w1,w2,w2,b1,b2)) |
|
for b1,b2,w1,w2 in [(5,2,4,5)] |
|
] + [ |
|
SupervisedTower("%d pyramid on top of %dx%d bricks"%(p,w1,w2), |
|
""" |
|
((for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6)))) |
|
(r 1) |
|
(for i %d (for j i (embed v (r 4) v (l 2) h)) (r 6)) |
|
(for i %d (for j (- %d i) (embed v (r 4) v (l 2) h)) (r 6))) |
|
"""%(w1,w2,w2,p,p,p)) |
|
for w1,w2,p in [(2,5,2)] |
|
] + \ |
|
[ |
|
SupervisedTower("%d tower on top of %dx%d bricks"%(t,w1,w2), |
|
""" |
|
((for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6)))) |
|
(r 6) |
|
%s (r 4) %s (l 2) h) |
|
"""%(w1,w2,w2, |
|
"v "*t, "v "*t)) |
|
for t,w1,w2 in [(4,1,3)] ] |
|
|
|
|
|
|
|
everything = arches + simpleLoops + Bridges + archesStacks + aqueducts + offsetArches + pyramids + bricks + staircase2 + staircase1 + compositions |
|
if False: |
|
for t in everything: |
|
delattr(t,'original') |
|
return everything |
|
|
|
def makeOldSupervisedTasks(): |
|
arches = [SupervisedTower("arch leg %d"%n, |
|
"((for i %d v) (r 4) (for i %d v) (l 2) h)"%(n,n)) |
|
for n in range(1,9) |
|
] |
|
archesStacks = [SupervisedTower("arch stack %d"%n, |
|
""" |
|
(for i %d |
|
v (r 4) v (l 2) h (l 2)) |
|
"""%n) |
|
for n in range(3,7) ] |
|
Bridges = [SupervisedTower("bridge (%d) of arch %d"%(n,l), |
|
""" |
|
(for j %d |
|
(for i %d |
|
v (r 4) v (l 4)) (r 2) h |
|
(r 4)) |
|
"""%(n,l)) |
|
for n in range(2,8) |
|
for l in range(1,6)] |
|
offsetArches = [SupervisedTower("bridge (%d) of arch, spaced %d"%(n,l), |
|
""" |
|
(for j %d |
|
v (r 4) v (l 2) h |
|
(r %d)) |
|
"""%(n,l)) |
|
for n,l in [(3,7),(4,6)]] |
|
Josh = [SupervisedTower("Josh (%d)"%n, |
|
"""(for i %d |
|
h (l 2) v (r 2) v (r 2) v (l 2) h (r 6))"""%n) |
|
for n in range(1,7) ] |
|
|
|
staircase1 = [SupervisedTower("R staircase %d"%n, |
|
""" |
|
(for i %d (for j i |
|
(embed v (r 4) v (l 2) h)) (r 6)) |
|
"""%(n)) |
|
for n in range(3,8) ] |
|
staircase2 = [SupervisedTower("L staircase %d"%n, |
|
""" |
|
(for i %d (for j i |
|
(embed v (r 4) v (l 2) h)) (l 6)) |
|
"""%(n)) |
|
for n in range(3,8) ] |
|
simpleLoops = [SupervisedTower("horizontal row %d, spacing %d"%(n,s), |
|
"""(for j %d h (r %s))"""%(n,s)) |
|
for n,s in [(4,6),(5,7)] ]+\ |
|
[SupervisedTower("horizontal stack %d"%n, |
|
"""(for j %d h)"""%n) |
|
for n in range(5,8) ]+\ |
|
[SupervisedTower("vertical stack %d"%n, |
|
"""(for j %d v)"""%n) |
|
for n in [5,7] ] |
|
pyramids = [] |
|
pyramids += [SupervisedTower("arch pyramid %d"%n, |
|
"""((for i %d (for j i (embed v (r 4) v (l 2) h)) (r 6)) |
|
(for i %d (for j (- %d i) (embed v (r 4) v (l 2) h)) (r 6)))"""%(n,n,n)) |
|
for n in range(2,6) ] |
|
pyramids += [SupervisedTower("H pyramid %d"%n, |
|
"""((for i %d (for j i h) (r 6)) |
|
(for i %d (for j (- %d i) h) (r 6)))"""%(n,n,n)) |
|
for n in range(4,6) ] |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pyramids += [SupervisedTower("H 1/2 pyramid %d"%n, |
|
""" |
|
(for i %d |
|
(r 6) |
|
(embed |
|
(for j i h (l 3)))) |
|
"""%n) |
|
for n in range(4,8) ] |
|
pyramids += [SupervisedTower("arch 1/2 pyramid %d"%n, |
|
""" |
|
(for i %d |
|
(r 6) |
|
(embed |
|
(for j i (embed v (r 4) v (l 2) h) (l 3)))) |
|
"""%n) |
|
for n in range(2,8) ] |
|
if False: |
|
pyramids += [SupervisedTower("V 1/2 pyramid %d"%n, |
|
""" |
|
(for i %d |
|
(r 2) |
|
(embed |
|
(for j i v (l 1))))"""%(n)) |
|
for n in range(4,8) ] |
|
bricks = [SupervisedTower("brickwall, %dx%d"%(w,h), |
|
"""(for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6))))"""%(h,w,w)) |
|
for w in range(3,7) |
|
for h in range(1,6) ] |
|
aqueducts = [SupervisedTower("aqueduct: %dx%d"%(w,h), |
|
"""(for j %d |
|
%s (r 4) %s (l 2) h (l 2) v (r 4) v (l 2) h (r 4))"""% |
|
(w, "v "*h, "v "*h)) |
|
for w in range(4,8) |
|
for h in range(3,6) |
|
] |
|
|
|
compositions = [SupervisedTower("%dx%d-bridge on top of %dx%d bricks"%(b1,b2,w1,w2), |
|
""" |
|
((for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6)))) |
|
(r 1) |
|
(for j %d |
|
(for i %d |
|
v (r 4) v (l 4)) (r 2) h |
|
(r 4))) |
|
"""%(w1,w2,w2,b1,b2)) |
|
for b1,b2,w1,w2 in [(5,2,4,5)] |
|
] + [ |
|
SupervisedTower("%d pyramid on top of %dx%d bricks"%(p,w1,w2), |
|
""" |
|
((for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6)))) |
|
(r 1) |
|
(for i %d (for j i (embed v (r 4) v (l 2) h)) (r 6)) |
|
(for i %d (for j (- %d i) (embed v (r 4) v (l 2) h)) (r 6))) |
|
"""%(w1,w2,w2,p,p,p)) |
|
for w1,w2,p in [(2,5,2)] |
|
] + \ |
|
[ |
|
SupervisedTower("%d tower on top of %dx%d bricks"%(t,w1,w2), |
|
""" |
|
((for j %d |
|
(embed (for i %d h (r 6))) |
|
(embed (r 3) (for i %d h (r 6)))) |
|
(r 6) |
|
%s (r 4) %s (l 2) h) |
|
"""%(w1,w2,w2, |
|
"v "*t, "v "*t)) |
|
for t,w1,w2 in [(4,1,3)] ] |
|
|
|
|
|
|
|
everything = arches + simpleLoops + Bridges + archesStacks + aqueducts + offsetArches + pyramids + bricks + staircase2 + staircase1 + compositions |
|
if False: |
|
for t in everything: |
|
delattr(t,'original') |
|
return everything |
|
|
|
def dSLDemo(): |
|
DSL = {} |
|
bricks = Program.parse("(lambda (lambda (tower_loopM $0 (lambda (lambda (moveHand 3 (reverseHand (tower_loopM $3 (lambda (lambda (moveHand 6 (3x1 $0)))) $0))))))))") |
|
DSL["bricks"] = [ [bricks.runWithArguments([x,y + 4,_empty_tower,TowerState()])[1] |
|
for y in range(6, 6 + 3*4, 3) ] |
|
for x in [3,8] ] |
|
dimensionality = {} |
|
dimensionality["bricks"] = 2 |
|
|
|
bridge = Program.parse("(lambda (lambda (tower_loopM $0 (lambda (lambda (#(lambda (#(lambda (lambda (lambda (tower_loopM $0 (lambda (lambda (1x3 (moveHand 4 ($3 $0))))) (moveHand 2 (3x1 $2)))))) $0 (lambda (reverseHand $0)))) (moveHand 4 $0) $3))))))") |
|
DSL["bridge"] = [ [bridge.runWithArguments([x,y,_empty_tower,TowerState()])[1] |
|
for x in range(4,4 + 2*4,2) ] |
|
for y in [4,9] ] |
|
dimensionality["bridge"] = 2 |
|
|
|
staircase = Program.parse("(lambda (tower_loopM $0 (lambda (lambda (#(lambda (lambda (tower_loopM $1 (lambda (lambda (tower_embed (lambda (#(lambda (1x3 (moveHand 4 (1x3 (reverseHand (moveHand 2 (3x1 $0))))))) $0)) $0))) $0))) $1 (moveHand 6 $0))))))") |
|
DSL["staircase"] = [ staircase.runWithArguments([n,_empty_tower,TowerState()])[1] |
|
for n in range(4,5 + 3) ] |
|
|
|
pyramid = Program.parse("(lambda (tower_loopM $0 (lambda (lambda (moveHand 6 (tower_embed (lambda (reverseHand ((lambda (lambda (tower_loopM $1 (lambda (lambda (moveHand $2 (1x3 (moveHand 2 (tower_embed (lambda (moveHand 2 (1x3 $0))) (3x1 $0)))))))))) $2 1 $0))) $0))))))") |
|
DSL["pyramid"] = [ pyramid.runWithArguments([n,_empty_tower,TowerState()])[1] |
|
for n in range(4,5 + 3) ] |
|
|
|
towerArch = Program.parse("(lambda (lambda ((lambda ((lambda (lambda (lambda (tower_loopM $0 (lambda (lambda (1x3 (moveHand 4 ($3 $0))))) (moveHand 2 (3x1 $2)))))) $0 (lambda (reverseHand (1x3 $0))))) $0 $1)))") |
|
DSL["towerArch"] = [ towerArch.runWithArguments([n,_empty_tower,TowerState()])[1] |
|
for n in range(4,5 + 3) ] |
|
|
|
images = {} |
|
for k,v in DSL.items(): |
|
d = dimensionality.get(k,1) |
|
if d == 1: |
|
i = montageMatrix([[renderPlan(p, pretty=True, Lego=True) for p in v]]) |
|
elif d == 2: |
|
i = montageMatrix([[renderPlan(p, pretty=True, Lego=True) for p in ps] for ps in v] ) |
|
else: assert False |
|
|
|
images[k] = i |
|
|
|
return images |
|
|
|
if __name__ == "__main__": |
|
from pylab import imshow,show |
|
from dreamcoder.domains.tower.tower_common import * |
|
|
|
ts = makeSupervisedTasks() |
|
print(len(ts),"total tasks") |
|
print("maximum plan length",max(len(f.plan) for f in ts )) |
|
print("maximum tower length",max(towerLength(f.plan) for f in ts )) |
|
print("maximum tower height",max(towerHeight(simulateWithoutPhysics(f.plan)) for f in ts )) |
|
SupervisedTower.exportMany("/tmp/every_tower.png",ts,shuffle=False) |
|
|
|
for j,t in enumerate(ts): |
|
t.exportImage("/tmp/tower_%d.png"%j, |
|
drawHand=False) |
|
|
|
for k,v in dSLDemo().items(): |
|
import scipy.misc |
|
scipy.misc.imsave(f"/tmp/tower_dsl_{k}.png", v) |
|
|
|
exampleTowers = [103,104,105,93,73, |
|
50,67,35,43,106] |
|
SupervisedTower.exportMany("/tmp/tower_montage.png", |
|
[ts[n] for n in exampleTowers ], |
|
columns=5, |
|
shuffle=False) |
|
assert False |
|
|
|
|
|
keywords = ["pyramid", |
|
"on top of", |
|
"arch 1/2 pyramid", |
|
"brickwall", |
|
"staircase", |
|
"bridge", |
|
"aqueduct", |
|
"spaced", |
|
"spaced", |
|
"arch stack"] |
|
for n in range(100): |
|
examples = [] |
|
for kw in keywords: |
|
if kw == "on top of": |
|
examples = examples + list(filter(lambda t: kw in str(t), ts)) |
|
else: |
|
examples.append(random.choice(list(filter(lambda t: kw in str(t), ts)))) |
|
|
|
random.shuffle(examples) |
|
SupervisedTower.exportMany("/tmp/tower10_%d.png"%n,examples, |
|
columns=int(len(examples)/2)) |
|
|
|
|
|
|
|
|
