def __init__(self, name,
width, height,
row, col,
nframes=3,
scale=2,
sheetfile='characters.png',
folder=os.path.join('data','images')):
pygame.sprite.Sprite.__init__(self)
sheet = loadImage(sheetfile, folder)
self.name = name
self.scale = scale
self.images = {}
for d,direction in enumerate(['south','west','east','north']):
self.images[direction] = []
for i in range(nframes):
image = pygame.Surface((width, height))
image.blit(sheet, (0,0), (((col+i)*width, (row+d)*height), (width,height)))
image.set_colorkey(image.get_at((0,0)))
image = pygame.transform.scale(image, ((scale*width), (scale*height)))
self.images[direction].append(image)
self.images[direction].append(self.images[direction][1])
self.direction = 'south'
self.speed = 0
self.image = self.images['south'][0]
self.rect = self.image.get_rect()
self.frame = 0.0
self.aspeed = 0.25
self.name = name
self.cellsize = (width*scale, height*scale)
self.timer = 0
def __init__(self, name, solid,
width, height,
row, col,
nframes=1,
horizontal=True,
addframe=True,
scale = 3,
sheetfile='things.png',
folder = os.path.join('data','images')):
pygame.sprite.Sprite.__init__(self)
self.solid = solid
sheet = loadImage(sheetfile, folder)
self.images = []
for frame in range(nframes):
img = pygame.Surface((width,height))
x = col*width
y = row*height
if horizontal:
x += frame*width
else:
y += frame*height
img.blit(sheet, (0,0), ((x,y),(width,height)))
img.set_colorkey(img.get_at((0,0)))
self.images.append(pygame.transform.scale(img, (width*scale,height*scale)))
self.image = self.images[0]
if addframe and nframes == 3:
self.images.append(self.images[1])
self.rect = self.image.get_rect()
self.frame = 0.0
self.aspeed = 0.125
self.name = name
self.opening = False
self.animated = False
def __init__(self,
name,
width,
height,
row,
col,
nframes=3,
scale=2,
sheetfile='characters.png',
folder=os.path.join('data', 'images')):
pygame.sprite.Sprite.__init__(self)
sheet = loadImage(sheetfile, folder)
self.name = name
self.scale = scale
self.images = {}
for d, direction in enumerate(['south', 'west', 'east', 'north']):
self.images[direction] = []
for i in range(nframes):
image = pygame.Surface((width, height))
image.blit(sheet, (0, 0),
(((col + i) * width, (row + d) * height),
(width, height)))
image.set_colorkey(image.get_at((0, 0)))
image = pygame.transform.scale(image, ((scale * width),
(scale * height)))
self.images[direction].append(image)
self.images[direction].append(self.images[direction][1])
self.direction = 'south'
self.speed = 0
self.image = self.images['south'][0]
self.rect = self.image.get_rect()
self.frame = 0.0
self.aspeed = 0.25
self.name = name
self.cellsize = (width * scale, height * scale)
self.timer = 0
def rankUsingPrograms():
results = pickle.load(open(arguments.name, 'rb'))
print " [+] Loaded %d synthesis results from %s." % (len(results),
arguments.name)
def getProgramForParse(sequence):
for r in results:
if sequence == r.parse and r.usedPrior():
return r
return None
def featuresOfParticle(p):
r = getProgramForParse(p.sequence())
if r != None and r.cost != None and r.source != None:
programFeatures = mergeDictionaries({'failure': 0.0},
parseSketchOutput(
r.source).features())
else:
programFeatures = {'failure': 1.0}
parseFeatures = {
'distance': p.distance[0] + p.distance[1],
'logPrior': p.sequence().logPrior(),
'logLikelihood': p.logLikelihood
}
return mergeDictionaries(parseFeatures, programFeatures)
k = arguments.learnToRank
topParticles = [
loadTopParticles('drawings/expert-%d-parses' % j, k)
for j in range(100)
]
learningProblems = []
for j, ps in enumerate(topParticles):
gt = getGroundTruthParse('drawings/expert-%d.png' % j)
positives = []
negatives = []
for p in ps:
if p.sequence() == gt: positives.append(p)
else: negatives.append(p)
if positives != [] and negatives != []:
learningProblems.append(
(map(featuresOfParticle,
positives), map(featuresOfParticle, negatives)))
featureIndices = list(
set([
f for pn in learningProblems for exs in pn for ex in exs
for f in ex.keys()
]))
def dictionaryToVector(featureMap):
return [featureMap.get(f, 0.0) for f in featureIndices]
learningProblems = [(map(dictionaryToVector,
positives), map(dictionaryToVector, negatives))
for positives, negatives in learningProblems]
parameters = learnToRank(learningProblems)
for f, p in zip(featureIndices, parameters):
print f, p
# showcases where it succeeds
programAccuracy = 0
oldAccuracy = 0
for j, tp in enumerate(topParticles):
if tp == []: continue
gt = getGroundTruthParse('drawings/expert-%d.png' % j)
# the_top_particles_according_to_the_learned_weights
featureVectors = np.array(
[dictionaryToVector(featuresOfParticle(p)) for p in tp])
particleScores = featureVectors.dot(parameters)
bestParticleUsingPrograms = max(zip(particleScores.tolist(), tp))[1]
programPredictionCorrect = False
if bestParticleUsingPrograms.sequence() == gt:
print "Prediction using the program is correct."
programPredictionCorrect = True
programAccuracy += 1
else:
print "Prediction using the program is incorrect."
oldPredictionCorrect = tp[0].sequence() == gt
print "Was the old prediction correct?", oldPredictionCorrect
oldAccuracy += int(oldPredictionCorrect)
visualization = np.zeros((256, 256 * 3))
visualization[:, :256] = 1 - frameImageNicely(
loadImage('drawings/expert-%d.png' % j))
visualization[:, 256:(256 * 2)] = frameImageNicely(
fastRender(tp[0].sequence()))
visualization[:, (256 * 2):(256 * 3)] = frameImageNicely(
fastRender(bestParticleUsingPrograms.sequence()))
visualization[:, 256] = 0.5
visualization[:, 256 * 2] = 0.5
visualization = 255 * visualization
if not oldPredictionCorrect and programPredictionCorrect:
fp = "../TikZpaper/figures/programSuccess%d.png" % j
print "Great success! see %s" % fp
saveMatrixAsImage(visualization, fp)
if oldPredictionCorrect and not programPredictionCorrect:
print "Minor setback!"
print particleScores
print programAccuracy, "vs", oldAccuracy
def viewSynthesisResults(arguments):
results = pickle.load(open(arguments.name, 'rb'))
print " [+] Loaded %d synthesis results." % (len(results))
interestingExtrapolations = [
7,
#14,
17,
29,
#35,
52,
57,
63,
70,
72,
88,
#99]
]
interestingExtrapolations = [
(16, 12), #*
#(17,0),
(18, 0), #*
#(22,0),
#(23,0),
#(29,12),
#(31,27),
(34, 0), #*
#(36,0),
#(38,12),
(39, 0), #*
#(41,1),
#(51,1),
#(52,12),
#(57,0),
#(58,0),
(60, 0), #*
#(63,0),
(66, 2), #*
(71, 1), #*
#(72,0),
#(73,0),
#(74,10),
#(75,5),
#(79,0),
#(85,1),
(86, 0), #*
#(88,0),
(90, 2), #*
#(92,0),
#(95,8)
]
#interestingExtrapolations = list(range(100))
latex = []
extrapolationMatrix = []
programFeatures = {}
for expertIndex in list(range(100)):
f = 'drawings/expert-%d.png' % expertIndex
parse = getGroundTruthParse(f)
if parse == None:
print "No ground truth for %d" % expertIndex
assert False
relevantResults = [
r for r in results if r.job.originalDrawing == f and r.cost != None
]
if relevantResults == []:
print "No synthesis result for %s" % f
result = None
else:
result = min(relevantResults, key=lambda r: r.cost)
equallyGoodResults = [
r for r in relevantResults if r.cost <= result.cost + 1
]
if len(equallyGoodResults) > 1:
print "Got %d results for %d" % (len(equallyGoodResults),
expertIndex)
programs = [ r.program.fixStringParameters().\
fixReflections(result.job.parse.canonicalTranslation()).removeDeadCode()
for r in equallyGoodResults ]
gt = result.job.parse.canonicalTranslation()
badPrograms = [
p for p in programs
if p.convertToSequence().canonicalTranslation() != gt
]
if badPrograms:
print " [-] WARNING: Got %d programs that are inconsistent with ground truth" % (
len(badPrograms))
if False:
for program in programs:
prediction = program.convertToSequence(
).canonicalTranslation()
actual = gt
if not (prediction == actual):
print "FATAL: program does notproduce spec"
print "Specification:"
print actual
print "Program:"
print program
print program.pretty()
print "Program output:"
print prediction
print set(map(str, prediction.lines))
print set(map(str, actual.lines))
print set(map(str, actual.lines)) ^ set(
map(str, prediction.lines))
assert False
if result == None and arguments.extrapolate:
print "Synthesis failure for %s" % f
continue
print " [+] %s" % f
print "\t(synthesis time: %s)" % (result.time if result else None)
print
if arguments.debug:
print result.source
if result != None:
syntaxTree = result.program.fixStringParameters()
syntaxTree = syntaxTree.fixReflections(
result.job.parse.canonicalTranslation())
print syntaxTree.pretty()
print syntaxTree.features()
print syntaxTree.convertToSequence()
#showImage(fastRender(syntaxTree.convertToSequence()) + loadImage(f)*0.5 + fastRender(result.parse))
programFeatures[f] = syntaxTree.features()
if arguments.extrapolate:
extrapolations = proposeExtrapolations(programs)
if extrapolations:
framedExtrapolations = [1 - frameImageNicely(loadImage(f))] + \
[ frameImageNicely(t.draw(adjustCanvasSize = True))
for t in extrapolations ]
a = 255 * makeImageArray(framedExtrapolations)
extrapolationMatrix.append(a)
print "Saving extrapolation column to", 'extrapolations/expert-%d-extrapolation.png' % expertIndex
saveMatrixAsImage(
a,
'extrapolations/expert-%d-extrapolation.png' % expertIndex)
if not arguments.extrapolate:
rightEntryOfTable = '''
\\begin{minipage}{10cm}
\\begin{verbatim}
%s
\\end{verbatim}
\\end{minipage}
''' % (syntaxTree.pretty() if result != None else "Solver timeout")
else:
rightEntryOfTable = ""
if False and extrapolations != [] and arguments.extrapolate:
#print e
rightEntryOfTable = '\\includegraphics[width = 5cm]{../TikZ/extrapolations/expert-%d-extrapolation.png}' % expertIndex
if rightEntryOfTable != "":
parseImage = '\\includegraphics[width = 5cm]{../TikZ/drawings/expert-%d-parses/0.png}' % expertIndex
if not os.path.exists(
'drawings/expert-%d-parses/0.png' % expertIndex):
parseImage = "Sampled no finished traces."
latex.append('''
\\begin{tabular}{lll}
\\includegraphics[width = 5cm]{../TikZ/drawings/expert-%d.png}&
%s&
%s
\\end{tabular}
''' % (expertIndex, parseImage, rightEntryOfTable))
print
if arguments.latex:
latex = '%s' % ("\\\\\n".join(latex))
name = "extrapolations.tex" if arguments.extrapolate else "synthesizerOutputs.tex"
with open('../TikZpaper/%s' % name, 'w') as handle:
handle.write(latex)
print "Wrote output to ../TikZpaper/%s" % name
if arguments.similarity:
analyzeFeatures(programFeatures)
if arguments.extrapolate:
#}make the big matrix
bigMatrix = np.zeros((max([m.shape[0] for m in extrapolationMatrix]),
256 * len(extrapolationMatrix)))
for j, r in enumerate(extrapolationMatrix):
bigMatrix[0:r.shape[0], 256 * j:256 * (j + 1)] = r
saveMatrixAsImage(bigMatrix, 'extrapolations/allTheExtrapolations.png')
# Function definitions:
def nothing(x):
pass
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True, help="Path to the image")
ap.add_argument("-o", "--option", required=True,
help="Option selecting the color to be checked")
ap.add_argument("-c", "--conf", required=True,
help="Path to the Json file in which to save the threshold values")
args = vars(ap.parse_args())
# load the image:
state,image = utils.loadImage(args["image"])
# Check that the input image was loaded correctly
if state == utils.SUCCESS:
# Creating a window for later use
window_title = "HSV Threshold configuration (" + args["option"] + ")"
cv2.namedWindow(window_title)
# Get previous configuration values:
state,configuration = utils.getConfigurationValues(args["option"],args["conf"])
# Check that the values were retrieved correctly
if state == utils.SUCCESS:
# Creating track bar
def viewSynthesisResults(arguments):
results = pickle.load(open(arguments.name,'rb'))
print " [+] Loaded %d synthesis results."%(len(results))
interestingExtrapolations = [7,
#14,
17,
29,
#35,
52,
57,
63,
70,
72,
88,
#99]
]
interestingExtrapolations = [(14,0),
(23,0),
(31,12),
(35,0),
(38,0),
(39,10),
(58,11),
(75,0),
(93,0),
(99,0)]
interestingExtrapolations = list(range(100))
latex = []
extrapolationMatrix = []
programFeatures = {}
for expertIndex in range(100):
if arguments.extrapolate:
if not any([ e == expertIndex or isinstance(e,tuple) and e[0] == expertIndex
for e in interestingExtrapolations ]):
continue
f = 'drawings/expert-%d.png'%expertIndex
parse = getGroundTruthParse(f)
if parse == None:
print "No ground truth for %d"%expertIndex
assert False
parts = set(map(str,parse.lines))
result = None
for r in results:
if isinstance(r,SynthesisResult) and r.originalDrawing == f:
if set(map(str,r.parse.lines)) == parts and r.usedPrior() == (not arguments.noPrior):
result = r
break
if expertIndex == 38: result = icingResult
if result == None:
print "No synthesis result for %s"%f
if arguments.extrapolate: continue
if result.source == None:
print "Synthesis failure for %s"%f
if arguments.extrapolate: continue
print " [+] %s"%f
print "\t(synthesis time: %f)"%(result.time)
print
if arguments.debug:
print result.source
if result != None and result.source != None:
syntaxTree = parseSketchOutput(result.source)
syntaxTree = syntaxTree.fixReflections(result.parse.canonicalTranslation())
print syntaxTree
print syntaxTree.features()
print syntaxTree.convertToPython()
print syntaxTree.convertToSequence()
#showImage(fastRender(syntaxTree.convertToSequence()) + loadImage(f)*0.5 + fastRender(result.parse))
programFeatures[f] = syntaxTree.features()
extrapolations = []
if arguments.extrapolate:
syntaxTree = syntaxTree.explode()
trace = syntaxTree.convertToSequence()
print trace
originalHasCollisions = result.parse.hasCollisions()
print "COLLISIONS",originalHasCollisions
framedExtrapolations = []
for e in syntaxTree.extrapolations():
t = e.convertToSequence()
if not originalHasCollisions and t.removeDuplicates().hasCollisions(): continue
if t == trace: continue
if any([t == o for o in extrapolations ]): continue
extrapolations.append(t)
framedExtrapolations.append(1 - frameImageNicely(1 - t.framedRendering(result.parse)))
if len(framedExtrapolations) > 20:
break
if framedExtrapolations != []:
for crap in interestingExtrapolations:
if isinstance(crap,tuple) and crap[0] == expertIndex:
framedExtrapolations = [framedExtrapolations[crap[1]]]
break
if arguments.debug:
framedExtrapolations = [loadImage(f), fastRender(syntaxTree.convertToSequence())] + framedExtrapolations
else:
framedExtrapolations = [frameImageNicely(loadImage(f))] + framedExtrapolations
a = np.zeros((256*len(framedExtrapolations),256))
for j,e in enumerate(framedExtrapolations):
a[j*256:(1+j)*256,:] = 1 - e
a[j*256,:] = 0.5
a[(1+j)*256-1,:] = 0.5
a[0,:] = 0.5
a[:,0] = 0.5
a[:,255] = 0.5
a[256*len(framedExtrapolations)-1,:] = 0.5
a = 255*a
# to show the first one
#a = a[:(256*2),:]
extrapolationMatrix.append(a)
saveMatrixAsImage(a,'extrapolations/expert-%d-extrapolation.png'%expertIndex)
if not arguments.extrapolate:
rightEntryOfTable = '''
\\begin{minipage}{10cm}
\\begin{verbatim}
%s
\\end{verbatim}
\\end{minipage}
'''%(parseSketchOutput(result.source).pretty() if result != None and result.source != None else "Solver timeout")
else:
rightEntryOfTable = ""
if extrapolations != [] and arguments.extrapolate:
#}make the big matrix
bigMatrix = np.zeros((max([m.shape[0] for m in extrapolationMatrix ]),256*len(extrapolationMatrix)))
for j,r in enumerate(extrapolationMatrix):
bigMatrix[0:r.shape[0],256*j:256*(j+1)] = r
if len(extrapolations) < 10 and False:
saveMatrixAsImage(bigMatrix,'../TikZpaper/figures/extrapolationMatrix.png')
else:
saveMatrixAsImage(bigMatrix,'../TikZpaper/figures/extrapolationMatrixSupplement.png')
print e
rightEntryOfTable = '\\includegraphics[width = 5cm]{../TikZ/extrapolations/expert-%d-extrapolation.png}'%expertIndex
if rightEntryOfTable != "":
parseImage = '\\includegraphics[width = 5cm]{../TikZ/drawings/expert-%d-parses/0.png}'%expertIndex
if not os.path.exists('drawings/expert-%d-parses/0.png'%expertIndex):
parseImage = "Sampled no finished traces."
latex.append('''
\\begin{tabular}{lll}
\\includegraphics[width = 5cm]{../TikZ/drawings/expert-%d.png}&
%s&
%s
\\end{tabular}
'''%(expertIndex, parseImage, rightEntryOfTable))
print
if arguments.latex:
latex = '%s'%("\\\\\n".join(latex))
name = "extrapolations.tex" if arguments.extrapolate else "synthesizerOutputs.tex"
with open('../TikZpaper/%s'%name,'w') as handle:
handle.write(latex)
print "Wrote output to ../TikZpaper/%s"%name
if arguments.similarity:
analyzeFeatures(programFeatures)
if x != y]
for (x,y),d in zip(indexes, distances):
matrix[x,y] += d
matrix = matrix + matrix.T
print "MATRIX:"
print matrix.tolist()
return matrix
if __name__ == '__main__':
worker = RecognitionModel(DummyArguments())
worker.loadDistanceCheckpoint("checkpoints/distance.checkpoint")
imageNames = ['drawings/expert-%d.png'%j
for j in range(100) ]
images = [ loadImage('/om/user/ellisk/%s'%n)
for n in imageNames ]
jobs = [(x,y) for j,x in enumerate(images)
for k,y in enumerate(images)
if j != k ]
distances = []
while jobs != []:
batch = jobs[:100]
jobs = jobs[100:]
print "%d jobs remaining"%len(jobs)
result = worker.learnedDistances(np.array([x for x,_ in batch ]),
np.array([x for _,x in batch ]))
for j in range(len(batch)):
distances.append(result[j,1] + result[j,0])
def initialize(self, scale = 3):
if self.initialized:
return self
self.initialized = True
# load all the tiles
self.tilefile = loadImage( self.tilefile, self.imagefolder, colorkey=None)
mapfile = open(os.path.join(self.datafolder, self.tilemap), 'r')
maplines = mapfile.read().splitlines()
self.dict = {}
for x in maplines:
mapping = [s.strip() for s in x.split(',')]
key = mapping[6]
self.dict[key] = {}
w,h = int(mapping[2]), int(mapping[3])
row, col = int(mapping[4]), int(mapping[5])
self.dict[key]['name'] = mapping[0]
self.dict[key]['file'] = mapping[1]
self.dict[key]['width'] = w
self.dict[key]['height'] = h
self.dict[key]['row'] = row
self.dict[key]['col'] = col
self.dict[key]['roomkey'] = mapping[6]
self.dict[key]['wall'] = mapping[7] == 'wall'
# find image for this tile
#w, h = self.dict[key]['width'], self.dict[key]['height']
#row, col = self.dict[key]['row'], self.dict[key]['col']
image = pygame.Surface((w,h))
image.blit(self.tilefile, (0,0),
((col*w, row*h), (w,h)))
image = pygame.transform.scale(image, (scale*w, scale*h))
letter = self.dict[key]['roomkey']
if letter in '12346':
w,h = image.get_size()
image.set_colorkey(image.get_at((w/2,h/2)))
elif letter in '578':
image.set_colorkey(image.get_at((0,0)))
self.dict[key]['image'] = image
# tile the room
roomfile = open(os.path.join(self.datafolder, self.room),'r')
roomrows = roomfile.read().splitlines()
self.tiles = pygame.sprite.RenderPlain()
self.tileArray = [[None for x in range(len(roomrows[0]))]
for y in range(len(roomrows))]
for roomrow, keys in enumerate(roomrows):
for roomcol, letter in enumerate(keys):
if letter == '.':
newTile = EmptyTile()
else:
data = self.dict[letter]
newTile = Tile(data['image'],
(roomcol*scale*w, roomrow*scale*h),
data['wall'])
if data['wall']:
newBlock = InvisibleBlock(
pygame.Rect(roomcol*scale*w, roomrow*scale*h,
scale*w, scale*h))
self.invisibleBlocks.append(newBlock)
self.tiles.add(newTile)
self.tileArray[roomrow][roomcol] = newTile
return self
B = 120.0 #Pixel min/max encourages pixels to be in the range of [-B, +B]
alphaNormLossWeight = 0.0001
TVNormLossWeight = args.tvnorm_weight
styleLossWeight = args.style_weight
contentLossWeight = args.content_weight
learningRate = args.learning_rate
numIters = args.train_iters
showEveryN = 500
##################
with tf.Session() as sess:
inputTensor = tf.placeholder(
tf.float32, shape=[None, imageShape[0], imageShape[1], imageShape[2]])
contentImage = np.array(utils.loadImage(contentPath, imageShape))
styleImage = utils.loadImage(stylePath, imageShape)
styleBalanceImage = utils.loadImage(contentPath, imageShape)
model = net.Vgg19()
model.build(inputTensor, imageShape)
contentData = eval('sess.run(model.' + contentLayer +
',feed_dict={inputTensor:contentImage})')
for styleLayer in styleLayers:
styleData[styleLayer] = np.array(
eval('sess.run(model.' + styleLayer +
',feed_dict={inputTensor:styleImage})'))
def buildStyleLoss(model):
totalStyleLoss = []
for index, styleLayer in enumerate(styleLayers):
def viewSynthesisResults(arguments):
results = pickle.load(open(arguments.name,'rb'))
print " [+] Loaded %d synthesis results."%(len(results))
interestingExtrapolations = [7,
#14,
17,
29,
#35,
52,
57,
63,
70,
72,
88,
#99]
]
interestingExtrapolations = [(16,12),#*
#(17,0),
(18,0),#*
#(22,0),
#(23,0),
#(29,12),
#(31,27),
(34,0),#*
#(36,0),
#(38,12),
(39,0),#*
#(41,1),
#(51,1),
#(52,12),
#(57,0),
#(58,0),
(60,0),#*
#(63,0),
(66,2),#*
(71,1),#*
#(72,0),
#(73,0),
#(74,10),
#(75,5),
#(79,0),
#(85,1),
(86,0),#*
#(88,0),
(90,2),#*
#(92,0),
#(95,8)
]
#interestingExtrapolations = list(range(100))
latex = []
extrapolationMatrix = []
programFeatures = {}
for expertIndex in list(range(100)):# + [101]:
if arguments.extrapolate:
if not any([ e == expertIndex or isinstance(e,tuple) and e[0] == expertIndex
for e in interestingExtrapolations ]):
continue
f = 'drawings/expert-%d.png'%expertIndex
parse = getGroundTruthParse(f)
if parse == None:
print "No ground truth for %d"%expertIndex
assert False
relevantResults = [ r for r in results if r.job.originalDrawing == f and r.cost != None ]
if relevantResults == []:
print "No synthesis result for %s"%f
result = None
else:
result = min(relevantResults, key = lambda r: r.cost)
equallyGoodResults = [ r for r in relevantResults if r.cost <= result.cost + 1 ]
if len(equallyGoodResults) > 1:
print "Got %d results for %d"%(len(equallyGoodResults),expertIndex)
programs = [ r.program.fixReflections(result.job.parse.canonicalTranslation()).removeDeadCode()
for r in equallyGoodResults ]
if result == None and arguments.extrapolate:
print "Synthesis failure for %s"%f
continue
print " [+] %s"%f
print "\t(synthesis time: %s)"%(result.time if result else None)
print
if arguments.debug:
print result.source
if result != None:
syntaxTree = result.program
syntaxTree = syntaxTree.fixReflections(result.job.parse.canonicalTranslation())
print syntaxTree
print syntaxTree.features()
print syntaxTree.convertToPython()
print syntaxTree.convertToSequence()
#showImage(fastRender(syntaxTree.convertToSequence()) + loadImage(f)*0.5 + fastRender(result.parse))
programFeatures[f] = syntaxTree.features()
extrapolations = []
if arguments.extrapolate:
syntaxTree = syntaxTree.explode()
trace = syntaxTree.convertToSequence().removeDuplicates()
print "original trace:"
print trace
originalUndesirability = parse.undesirabilityVector()
print "original undesirability",originalUndesirability
framedExtrapolations = []
extrapolationGenerators = [ program.explode().extrapolations() for program in programs ]
for e in interleaveGenerators(extrapolationGenerators):
t = e.convertToSequence().removeDuplicates()
newUndesirability = t.undesirabilityVector()
if (newUndesirability > originalUndesirability).sum() > 0: continue
if t.canonicalTranslation() == trace.canonicalTranslation(): continue
if any([t.canonicalTranslation() == o.canonicalTranslation() for o in extrapolations ]): continue
extrapolations.append(t)
framedExtrapolations.append(1 - frameImageNicely(t.draw(adjustCanvasSize = True)))
if len(framedExtrapolations) > 30:
break
if framedExtrapolations != []:
for crap in interestingExtrapolations:
if isinstance(crap,tuple) and crap[0] == expertIndex:
print "Just taking the %d extrapolation..."%(crap[1])
framedExtrapolations = [framedExtrapolations[crap[1]]]
break
if arguments.debug:
framedExtrapolations = [loadImage(f), syntaxTree.convertToSequence().draw()] + framedExtrapolations
else:
framedExtrapolations = [frameImageNicely(loadImage(f))] + framedExtrapolations
a = np.zeros((256*len(framedExtrapolations),256))
for j,e in enumerate(framedExtrapolations):
a[j*256:(1+j)*256,:] = 1 - e
a[j*256,:] = 0.5
a[(1+j)*256-1,:] = 0.5
a[0,:] = 0.5
a[:,0] = 0.5
a[:,255] = 0.5
a[256*len(framedExtrapolations)-1,:] = 0.5
a = 255*a
# to show the first one
#a = a[:(256*2),:]
extrapolationMatrix.append(a)
print "Saving extrapolation column to",'extrapolations/expert-%d-extrapolation.png'%expertIndex
saveMatrixAsImage(a,'extrapolations/expert-%d-extrapolation.png'%expertIndex)
if not arguments.extrapolate:
rightEntryOfTable = '''
\\begin{minipage}{10cm}
\\begin{verbatim}
%s
\\end{verbatim}
\\end{minipage}
'''%(syntaxTree.pretty() if result != None else "Solver timeout")
else:
rightEntryOfTable = ""
if False and extrapolations != [] and arguments.extrapolate:
#print e
rightEntryOfTable = '\\includegraphics[width = 5cm]{../TikZ/extrapolations/expert-%d-extrapolation.png}'%expertIndex
if rightEntryOfTable != "":
parseImage = '\\includegraphics[width = 5cm]{../TikZ/drawings/expert-%d-parses/0.png}'%expertIndex
if not os.path.exists('drawings/expert-%d-parses/0.png'%expertIndex):
parseImage = "Sampled no finished traces."
latex.append('''
\\begin{tabular}{lll}
\\includegraphics[width = 5cm]{../TikZ/drawings/expert-%d.png}&
%s&
%s
\\end{tabular}
'''%(expertIndex, parseImage, rightEntryOfTable))
print
if arguments.latex:
latex = '%s'%("\\\\\n".join(latex))
name = "extrapolations.tex" if arguments.extrapolate else "synthesizerOutputs.tex"
with open('../TikZpaper/%s'%name,'w') as handle:
handle.write(latex)
print "Wrote output to ../TikZpaper/%s"%name
if arguments.similarity:
analyzeFeatures(programFeatures)
if arguments.extrapolate:
#}make the big matrix
bigMatrix = np.zeros((max([m.shape[0] for m in extrapolationMatrix ]),256*len(extrapolationMatrix)))
for j,r in enumerate(extrapolationMatrix):
bigMatrix[0:r.shape[0],256*j:256*(j+1)] = r
saveMatrixAsImage(bigMatrix,'extrapolations/allTheExtrapolations.png')
def initialize(self, scale=3):
if self.initialized:
return self
self.initialized = True
# load all the tiles
self.tilefile = loadImage(self.tilefile,
self.imagefolder,
colorkey=None)
mapfile = open(os.path.join(self.datafolder, self.tilemap), 'r')
maplines = mapfile.read().splitlines()
self.dict = {}
for x in maplines:
mapping = [s.strip() for s in x.split(',')]
key = mapping[6]
self.dict[key] = {}
w, h = int(mapping[2]), int(mapping[3])
row, col = int(mapping[4]), int(mapping[5])
self.dict[key]['name'] = mapping[0]
self.dict[key]['file'] = mapping[1]
self.dict[key]['width'] = w
self.dict[key]['height'] = h
self.dict[key]['row'] = row
self.dict[key]['col'] = col
self.dict[key]['roomkey'] = mapping[6]
self.dict[key]['wall'] = mapping[7] == 'wall'
# find image for this tile
#w, h = self.dict[key]['width'], self.dict[key]['height']
#row, col = self.dict[key]['row'], self.dict[key]['col']
image = pygame.Surface((w, h))
image.blit(self.tilefile, (0, 0), ((col * w, row * h), (w, h)))
image = pygame.transform.scale(image, (scale * w, scale * h))
letter = self.dict[key]['roomkey']
if letter in '12346':
w, h = image.get_size()
image.set_colorkey(image.get_at((w / 2, h / 2)))
elif letter in '578':
image.set_colorkey(image.get_at((0, 0)))
self.dict[key]['image'] = image
# tile the room
roomfile = open(os.path.join(self.datafolder, self.room), 'r')
roomrows = roomfile.read().splitlines()
self.tiles = pygame.sprite.RenderPlain()
self.tileArray = [[None for x in range(len(roomrows[0]))]
for y in range(len(roomrows))]
for roomrow, keys in enumerate(roomrows):
for roomcol, letter in enumerate(keys):
if letter == '.':
newTile = EmptyTile()
else:
data = self.dict[letter]
newTile = Tile(data['image'],
(roomcol * scale * w, roomrow * scale * h),
data['wall'])
if data['wall']:
newBlock = InvisibleBlock(
pygame.Rect(roomcol * scale * w,
roomrow * scale * h, scale * w,
scale * h))
self.invisibleBlocks.append(newBlock)
self.tiles.add(newTile)
self.tileArray[roomrow][roomcol] = newTile
return self
def analyzeFeatures(featureMaps):
from sklearn.decomposition import PCA, NMF
from sklearn import preprocessing
from sklearn.manifold import MDS
import matplotlib.pyplot as plot
import matplotlib.image as image
# collect together a whole of the different names for features
featureNames = list(set([k for f in featureMaps.values() for k in f]))
imageNames = featureMaps.keys()
# Convert feature maps into vectors
featureVectors = [[featureMaps[k].get(name, 0) for name in featureNames]
for k in imageNames]
print "Feature vectors:"
for j, n in enumerate(imageNames):
print n
print featureMaps[n]
print featureVectors[j]
# Figure out things that are close / far as measured by different metrics
percentile = 80
imageDistances = learnedDistanceMatrix(None)
numberOfPrograms = len(featureVectors)
programDistances = np.zeros((numberOfPrograms, numberOfPrograms))
featureVectors = preprocessing.scale(np.array(featureVectors))
for j in range(numberOfPrograms):
for k in range(numberOfPrograms):
programDistances[j, k] = (
(featureVectors[j, :] - featureVectors[k, :]) *
(featureVectors[j, :] - featureVectors[k, :])).sum()
smallDistance = np.percentile(programDistances, 100 - percentile)
bigDistance = np.percentile(programDistances, percentile)
closePrograms = set([(n1, n2) for j, n1 in enumerate(imageNames)
for k, n2 in enumerate(imageNames)
if n1 < n2 and programDistances[j, k] < smallDistance
])
farPrograms = set([(n1, n2) for j, n1 in enumerate(imageNames)
for k, n2 in enumerate(imageNames)
if n1 < n2 and programDistances[j, k] > bigDistance])
smallDistance = np.percentile(imageDistances, 100 - percentile)
bigDistance = np.percentile(imageDistances, percentile)
imageNames = ["drawings/expert-%d.png" % j for j in range(100)]
closeImages = set([(n1, n2) for j, n1 in enumerate(imageNames)
for k, n2 in enumerate(imageNames)
if n1 < n2 and imageDistances[j, k] < smallDistance])
farImages = set([(n1, n2) for j, n1 in enumerate(imageNames)
for k, n2 in enumerate(imageNames)
if n1 < n2 and imageDistances[j, k] > bigDistance])
programOptions = [(closePrograms, 'close in program space'),
(farPrograms, 'distant in program space')]
imageOptions = [(closeImages, 'close in image space'),
(farImages, 'far in image space')]
for programSet, programName in programOptions:
for imageSet, imageName in imageOptions:
overlap = programSet & imageSet
print programName, '&', imageName, 'have overlap', len(overlap)
overlap = list(sorted(list(overlap)))
indices = np.random.choice(range(len(overlap)),
size=min(100, len(overlap)),
replace=False)
overlap = [overlap[j] for j in indices]
matrix = 1 - np.concatenate([
np.concatenate((loadImage(n1), loadImage(n2)), axis=0)
for n1, n2 in overlap
],
axis=1)
saveMatrixAsImage(matrix * 255,
"similarity/%s%s.png" % (programName, imageName))
assert False
for algorithm in [0, 1, 2]:
if algorithm == 0:
learner = PCA()
transformedFeatures = learner.fit_transform(
preprocessing.scale(np.array(featureVectors)))
print learner.explained_variance_ratio_
if algorithm == 1:
learner = NMF(2)
transformedFeatures = learner.fit_transform(
preprocessing.scale(np.array(featureVectors), with_mean=False))
if algorithm == 2:
imageNames = ["drawings/expert-%d.png" % j for j in range(100)]
distances = learnedDistanceMatrix(map(loadImage, imageNames))
learner = MDS(dissimilarity='precomputed')
transformedFeatures = learner.fit_transform(distances)
print transformedFeatures
maximumExtent = max([
transformedFeatures[:, 0].max() - transformedFeatures[:, 0].min(),
transformedFeatures[:, 1].max() - transformedFeatures[:, 1].min()
])
print maximumExtent
w = 0.1 * maximumExtent
if algorithm < 2:
print learner.components_
for dimension in range(2):
coefficients = learner.components_[dimension]
print "Dimension %d:" % (dimension + 1)
for j, n in enumerate(featureNames):
print n, '\t', learner.components_[dimension, j]
print
showProbability = []
for j in range(len(imageNames)):
overlapping = 0
for k in range(len(imageNames)):
if j == k: continue
d = abs(transformedFeatures[j, :2] -
transformedFeatures[k, :2])
if d[0] < 2 * w and d[1] < 2 * w:
overlapping += 1
showProbability.append(1.0 / (1 + overlapping * 0.3))
for index in range(50):
f, a = plot.subplots()
imageIsShown = [random.random() < sp for sp in showProbability]
coolImages = [38, 39, 12, 26, 46, 47, 76, 71, 75, 80, 89]
for coolImage in coolImages:
coolImage = 'drawings/expert-%d.png' % coolImage
for j, imageName in enumerate(imageNames):
if imageName == coolImage:
imageIsShown[j] = True
break
imageCoordinates = [
transformedFeatures[j, :2] for j in range(len(imageNames))
]
imageCoordinates = diffuseImagesOutwards(imageCoordinates, w,
imageIsShown)
for j, imageName in enumerate(imageNames):
if not imageIsShown[j]: continue
i = 1 - image.imread(imageName)
i = 1 - removeBorder(i)
x = imageCoordinates[j][0]
y = imageCoordinates[j][1]
a.imshow(i,
aspect='auto',
extent=(x - w, x + w, y - w, y + w),
zorder=-1,
cmap=plot.get_cmap('Greys'))
a.arrow(x,
y,
transformedFeatures[j, 0] - x,
transformedFeatures[j, 1] - y,
head_width=0.04,
head_length=0.1,
fc='k',
ec='k',
zorder=-2)
a.scatter(transformedFeatures[:, 0], transformedFeatures[:, 1])
a.get_yaxis().set_visible(False)
a.get_xaxis().set_visible(False)
n = ['PCA', 'NMF', 'MDS'][algorithm]
plot.savefig('%s/%s%d.png' % (n, n, index), bbox_inches='tight')
# if x != y]
# for (x,y),d in zip(indexes, distances):
# matrix[x,y] += d
# matrix = matrix + matrix.T
# print "MATRIX:"
# print matrix.tolist()
# return matrix
if __name__ == '__main__':
worker = RecognitionModel(DummyArguments())
worker.loadDistanceCheckpoint("checkpoints/distance.checkpoint")
imageNames = ['drawings/expert-%d.png' % j for j in range(100)]
images = [loadImage(n) for n in imageNames]
jobs = [(x, y) for j, x in enumerate(images) for k, y in enumerate(images)
if j != k]
distances = []
while jobs != []:
batch = jobs[:100]
jobs = jobs[100:]
print "%d jobs remaining" % len(jobs)
result = worker.learnedDistances(np.array([x for x, _ in batch]),
np.array([x for _, x in batch]))
for j in range(len(batch)):
distances.append(result[j, 1] + result[j, 0])
matrix = np.zeros((len(images), len(images)))
