def inference_LoadProgram(self):
MyRIPL = self.RIPL
try:
self.LoadProgram(explore_Joint=0)
except ConnectionError:
return -1
MyRIPL.observe(
lisp_parser.parse(
"(noisy-image-compare test-image rendered-image pflip)"),
"true")
r = openGLText.openGLText(self.filename)
logsArray = []
pxdisagreeArr = []
lettercountArr = []
globalBlurArr = []
blurArr = dict()
for i in range(MAX_LETTERS):
blurArr[i] = []
pflipArr = []
baselineIm = Image.open(self.filename).convert("L")
baselineIm = asarray(baselineIm)
chrs = self.predictCharacteres()
cnt = 0
## directory to hold all plots
now = SEED + '_MAX_LETTERS_' + str(MAX_LETTERS) + '_' + str(
datetime.datetime.now())
dst = "dump/" + now
os.makedirs(dst)
os.makedirs(dst + '/composite')
os.makedirs(dst + '/logscore')
os.makedirs(dst + '/pxdisagree')
os.makedirs(dst + '/globalblur')
os.makedirs(dst + '/variance')
os.makedirs(dst + '/blur')
os.makedirs(dst + '/lettercount')
os.makedirs(dst + '/images')
os.makedirs(dst + '/pickle')
while cnt < 352:
MyRIPL.infer(100)
pflip = MyRIPL.report_value(self._pflip)
global_blur = MyRIPL.report_value(self._global_blur)
globalBlurArr.append(global_blur)
things = []
letter_count = 0
for i in range(MAX_LETTERS):
posx, posy, size_x, size_y, rotate_z, _id, blur, present = self.reportCharacters(
chrs, i)
print present, pflip
if present == True:
letter_count += 1
things.append({
'id': chr(int(_id) + 65),
'size_x': size_x,
'size_y': size_y,
'rotate_z': rotate_z,
'left': posx,
'top': posy,
'blur_sigsq': blur
})
#print "left():",posx," top():", posy," size_x:", size_x, " size_y:", size_y, " rotate_z:", rotate_z,chr(_id+65)," blur: ",blur,"| pflip:", pflip, '\n'
blurArr[i].append(blur)
else:
blurArr[i].append(0)
cnt = cnt + 1
im = r.get_rendered_image(things, global_blur)
scipy.misc.imsave(dst + str('/images/') + str(cnt) + '.png', im)
logscore = MyRIPL.logscore()
logsArray.append(logscore['logscore'])
print 'LOGSCORE:', logscore, "|", cnt
diff = sum(abs(im - baselineIm))
pxdisagreeArr.append(diff)
pflipArr.append(pflip)
lettercountArr.append(letter_count)
###################################### PLOTTING HARNESS ############################################
self.composite(baselineIm, im, range(cnt), logsArray,
pxdisagreeArr, globalBlurArr, pflipArr,
dst + str('/composite/') + str(cnt) + '.png')
if cnt % 30 == 0:
OBJ = {
'logscore': logsArray,
'pxdisagree': pxdisagreeArr,
'variance': pflipArr,
'letter-count': lettercountArr,
'global-blur': globalBlurArr,
'letter-blur': blurArr
}
pickle.dump(
OBJ, open(dst + str('/pickle/') + str(cnt) + '.pkl', 'wb'))
self.savePlot(range(cnt), logsArray, "LOG-SCORE", "Iterations",
"logscore",
dst + str('/logscore/') + str(cnt) + '.png')
self.savePlot(range(cnt), pxdisagreeArr, "PX-DISAGREE",
"Iterations", "pxdisagree",
dst + str('/pxdisagree/') + str(cnt) + '.png')
self.savePlot(range(cnt), pflipArr, "VARIANCE", "Iterations",
"variance",
dst + str('/variance/') + str(cnt) + '.png')
self.savePlot(range(cnt), lettercountArr, "LETTER-COUNT",
"Iterations", "letter count",
dst + str('/lettercount/') + str(cnt) + '.png')
self.savePlot(range(cnt), globalBlurArr, "GLOBAL-BLUR",
"Iterations", "blur",
dst + str('/globalblur/') + str(cnt) + '.png')
for jj in range(MAX_LETTERS):
self.savePlot(
range(cnt), blurArr[jj], "BLUR-LETTER-" + str(jj),
"Iterations", "blur", dst + str('/blur/') + str(cnt) +
'_' + str(jj) + '.png')
def LoadProgram(self):
MyRIPL = self.RIPL
MyRIPL.clear() # To delete previous sessions data.
chrs = self.createCharacter()
(_alpha,tmp) = MyRIPL.assume("alpha", lisp_parser.parse("(uniform-continuous 0.01 8)"))
(_pflip,tmp)= MyRIPL.assume("pflip", lisp_parser.parse("(uniform-continuous 0.0 1.0)"))
MyRIPL.assume("LOAD-IMAGE", lisp_parser.parse("1"))
MyRIPL.assume("RENDER-IMAGE", lisp_parser.parse("10"))
MyRIPL.assume("NOISY-COMP", lisp_parser.parse("3"))
MyRIPL.assume("load-image", lisp_parser.parse("(load-remote-xrp 4444 LOAD-IMAGE)"))
MyRIPL.assume("render-image", lisp_parser.parse("(load-remote-xrp 4444 RENDER-IMAGE)"))
MyRIPL.assume("noisy-image-compare", lisp_parser.parse("(load-remote-xrp 4444 NOISY-COMP)"))
MyRIPL.assume("test-image", lisp_parser.parse("(load-image 0 0 0 0 0)")) #FIXME - dynamic args
arguments = ""
for i in range(NUM_LETTERS):
arguments += " posx"+str(i)+" "+"posy"+str(i)+" "+"id"+str(i)+" "+"size"+str(i)+" "+"blur"+str(i) + " 1"
MyRIPL.assume("rendered-image", lisp_parser.parse("(render-image " + arguments + ")")) #FIXME - dynamic args
MyRIPL.observe(lisp_parser.parse("(noisy-image-compare test-image rendered-image pflip)"), "true")
r = openGLText.openGLText()
logsArray = []
pxdisagreeArr = []
blurArr = []
pflipArr = []
baselineIm = Image.open("cvprtext.png").convert("L")
baselineIm = asarray(baselineIm)
cnt = 0
while cnt < 200:
MyRIPL.infer(50)
pflip = MyRIPL.report_value(_pflip)
alpha = MyRIPL.report_value(_alpha)
things = []
for i in range(len(chrs)):
posx,posy,size,_id,blur = self.reportCharacters(chrs[i])
things.append({'id':chr(int(_id)+65), 'size':size, 'left':posx, 'top':posy,'blur_sigsq':blur})
print "left():",posx," top():", posy," size():", size,chr(_id+65)," blur: ",blur,"| pflip:", pflip, "|", alpha
print "####\n"
im = r.get_rendered_image(things)
scipy.misc.imsave('inference.jpg', im)
logscore = MyRIPL.logscore()
logsArray.append(logscore['logscore'])
compound = im+baselineIm
intersection_ones = len(where(compound == 2)[0])
intersection_zeros = len(where(compound == 0)[0])
intersection = intersection_zeros + intersection_ones
pxdisagreeArr.append(float(RES-intersection)/RES)
pflipArr.append(pflip)
blurArr.append(blur)
print 'LOGSCORE:', logscore, "|", cnt
cnt = cnt + 1
#self.initPlottingHarness(baselineIm,im,range(cnt),logsArray,pxdisagreeArr,pflipArr,blurArr,cnt)
self.demoPlotting(baselineIm,im,range(cnt),logsArray,pxdisagreeArr,pflipArr,blurArr,cnt)
""" # add directives needed
def LoadProgram(self):
MyRIPL = self.RIPL
MyRIPL.clear() # To delete previous sessions data.
MyRIPL.assume("flip-relax", lisp_parser.parse("(mem (lambda(letter-id) (beta 1 2)))"))
MyRIPL.assume("letter-present", lisp_parser.parse("(mem (lambda(letter-id) (bernoulli (flip-relax letter-id) )))"))
"""MyRIPL.assume("flip-relax-relax", lisp_parser.parse("(mem (lambda(letter-id) (uniform-continuous 1.0 3.0)))"))
MyRIPL.assume("flip-relax", lisp_parser.parse("(mem (lambda(letter-id) (beta 10 (flip-relax-relax letter-id))))"))
MyRIPL.assume("letter-present", lisp_parser.parse("(mem (lambda(letter-id) (bernoulli (flip-relax letter-id) )))"))"""
self.RIPL.assume("posx", lisp_parser.parse("(mem (lambda (letter-id) (uniform-discrete 0 150)))")) #0 -140 captcha
self.RIPL.assume("posy", lisp_parser.parse("(mem (lambda (letter-id) (uniform-discrete 0 150)))")) #0 - 100 captcha #56-64 ocr
self.RIPL.assume("size_x", lisp_parser.parse("(mem (lambda (letter-id) (uniform-discrete 30 70)))")) #30-70 captcha
self.RIPL.assume("size_y", lisp_parser.parse("(mem (lambda (letter-id) (size_x letter-id)))")) #30-70 captcha
self.RIPL.assume("rotate_z", lisp_parser.parse("(mem (lambda (letter-id) (uniform-continuous -40.0 40.0)))")) #30-70 captcha
self.RIPL.assume("id", lisp_parser.parse("(mem (lambda (letter-id) (uniform-discrete 0 2)))")) #0 -2
#self.RIPL.assume("blur", lisp_parser.parse("(mem (lambda (letter-id) (gamma 1 1)))")) # 0 - 10
self.RIPL.assume("blur", lisp_parser.parse("(* 10 (beta 1 10))")) # 0 - 10
(_alpha,tmp) = MyRIPL.assume("alpha", lisp_parser.parse("(uniform-continuous 0 20)"))
(_pflip,tmp)= MyRIPL.assume("pflip", lisp_parser.parse("(/ (beta 1 5) 2)")) #beta 6 1 works reasonably
MyRIPL.assume("LOAD-IMAGE", lisp_parser.parse("1"))
MyRIPL.assume("RENDER-IMAGE", lisp_parser.parse("10"))
MyRIPL.assume("NOISY-COMP", lisp_parser.parse("3"))
MyRIPL.assume("load-image", lisp_parser.parse("(load-remote-xrp 4444 LOAD-IMAGE)"))
MyRIPL.assume("render-image", lisp_parser.parse("(load-remote-xrp 4444 RENDER-IMAGE)"))
MyRIPL.assume("noisy-image-compare", lisp_parser.parse("(load-remote-xrp 4444 NOISY-COMP)"))
MyRIPL.assume("test-image", lisp_parser.parse("(load-image 0 0 0 0 0)")) #FIXME - dynamic args
arguments = ""
for i in range(MAX_LETTERS):
#arguments += " (posx "+str(i)+") " + " (posy "+str(i)+") " + " (id "+str(i)+") " + " (size_x "+str(i)+") " + " (size_y "+str(i)+") " + " (rotate_z "+str(i)+") " + " (blur "+str(i)+") " + " (letter-present "+str(i)+") "
arguments += " (posx "+str(i)+") " + " (posy "+str(i)+") " + " (id "+str(i)+") " + " (size_x "+str(i)+") " + " (size_y "+str(i)+") " + " (rotate_z "+str(i)+") " + " blur" + " (letter-present "+str(i)+") "
MyRIPL.assume("rendered-image", lisp_parser.parse("(render-image " + arguments + ")")) #FIXME - dynamic args
MyRIPL.observe(lisp_parser.parse("(noisy-image-compare test-image rendered-image pflip)"), "true")
r = openGLText.openGLText()
r.loadImage("")
logsArray = []
pxdisagreeArr = []
blurArr = []
pflipArr = []
baselineIm = Image.open("demo.jpg").convert("L")
baselineIm = asarray(baselineIm)
chrs = self.predictCharacteres()
cnt = 0
while cnt < 200:
MyRIPL.infer(100)
pflip = MyRIPL.report_value(_pflip)
things = []
for i in range(MAX_LETTERS):
posx,posy,size_x,size_y,rotate_z,_id,blur,present = self.reportCharacters(chrs,i)
print present, pflip
if present == True:
things.append({'id':chr(int(_id)+65), 'size_x':size_x, 'size_y':size_y, 'rotate_z':rotate_z, 'left':posx, 'top':posy,'blur_sigsq':blur})
print "left():",posx," top():", posy," size_x:", size_x, " size_y:", size_y, " rotate_z:", rotate_z,chr(_id+65)," blur: ",blur,"| pflip:", pflip
print "####\n"
im = r.get_rendered_image(things)
scipy.misc.imsave('inference.jpg', im)
logscore = MyRIPL.logscore()
logsArray.append(logscore['logscore'])
compound = im+baselineIm
intersection_ones = len(where(compound == 2)[0])
intersection_zeros = len(where(compound == 0)[0])
intersection = intersection_zeros + intersection_ones
pxdisagreeArr.append(float(RES-intersection)/RES)
pflipArr.append(pflip)
blurArr.append(blur)
print 'LOGSCORE:', logscore, "|", cnt
cnt = cnt + 1
self.initPlottingHarness(baselineIm,im,range(cnt),logsArray,pxdisagreeArr,pflipArr,blurArr,cnt)
#self.demoPlotting(baselineIm,im,range(cnt),logsArray,pxdisagreeArr,pflipArr,blurArr,cnt)
""" # add directives needed
def LoadProgram(self):
MyRIPL = self.RIPL
MyRIPL.clear() # To delete previous sessions data.
chrs = self.createCharacter()
(_alpha,
tmp) = MyRIPL.assume("alpha",
lisp_parser.parse("(uniform-continuous 0.01 8)"))
(_pflip, tmp) = MyRIPL.assume(
"pflip", lisp_parser.parse("(uniform-continuous 0.0 1.0)"))
MyRIPL.assume("LOAD-IMAGE", lisp_parser.parse("1"))
MyRIPL.assume("RENDER-IMAGE", lisp_parser.parse("10"))
MyRIPL.assume("NOISY-COMP", lisp_parser.parse("3"))
MyRIPL.assume("load-image",
lisp_parser.parse("(load-remote-xrp 4444 LOAD-IMAGE)"))
MyRIPL.assume("render-image",
lisp_parser.parse("(load-remote-xrp 4444 RENDER-IMAGE)"))
MyRIPL.assume("noisy-image-compare",
lisp_parser.parse("(load-remote-xrp 4444 NOISY-COMP)"))
MyRIPL.assume(
"test-image",
lisp_parser.parse("(load-image 0 0 0 0 0)")) #FIXME - dynamic args
arguments = ""
for i in range(NUM_LETTERS):
arguments += " posx" + str(i) + " " + "posy" + str(
i) + " " + "id" + str(i) + " " + "size" + str(
i) + " " + "blur" + str(i) + " 1"
MyRIPL.assume("rendered-image",
lisp_parser.parse("(render-image " + arguments +
")")) #FIXME - dynamic args
MyRIPL.observe(
lisp_parser.parse(
"(noisy-image-compare test-image rendered-image pflip)"),
"true")
r = openGLText.openGLText()
logsArray = []
pxdisagreeArr = []
blurArr = []
pflipArr = []
baselineIm = Image.open("cvprtext.png").convert("L")
baselineIm = asarray(baselineIm)
cnt = 0
while cnt < 200:
MyRIPL.infer(50)
pflip = MyRIPL.report_value(_pflip)
alpha = MyRIPL.report_value(_alpha)
things = []
for i in range(len(chrs)):
posx, posy, size, _id, blur = self.reportCharacters(chrs[i])
things.append({
'id': chr(int(_id) + 65),
'size': size,
'left': posx,
'top': posy,
'blur_sigsq': blur
})
print "left():", posx, " top():", posy, " size():", size, chr(
_id + 65), " blur: ", blur, "| pflip:", pflip, "|", alpha
print "####\n"
im = r.get_rendered_image(things)
scipy.misc.imsave('inference.jpg', im)
logscore = MyRIPL.logscore()
logsArray.append(logscore['logscore'])
compound = im + baselineIm
intersection_ones = len(where(compound == 2)[0])
intersection_zeros = len(where(compound == 0)[0])
intersection = intersection_zeros + intersection_ones
pxdisagreeArr.append(float(RES - intersection) / RES)
pflipArr.append(pflip)
blurArr.append(blur)
print 'LOGSCORE:', logscore, "|", cnt
cnt = cnt + 1
#self.initPlottingHarness(baselineIm,im,range(cnt),logsArray,pxdisagreeArr,pflipArr,blurArr,cnt)
self.demoPlotting(baselineIm, im, range(cnt), logsArray,
pxdisagreeArr, pflipArr, blurArr, cnt)
""" # add directives needed
def inference_LoadProgram(self):
MyRIPL = self.RIPL
try:
self.LoadProgram(explore_Joint=0)
except ConnectionError:
return -1
MyRIPL.observe(lisp_parser.parse("(noisy-image-compare test-image rendered-image pflip)"), "true")
r = openGLText.openGLText(self.filename)
logsArray = []
pxdisagreeArr = []
lettercountArr = []
globalBlurArr =[]
blurArr = dict()
for i in range(MAX_LETTERS):
blurArr[i] = []
pflipArr = []
baselineIm = Image.open(self.filename).convert("L")
baselineIm = asarray(baselineIm)
chrs = self.predictCharacteres()
cnt = 0
## directory to hold all plots
now = SEED + '_MAX_LETTERS_'+ str(MAX_LETTERS)+ '_' + str(datetime.datetime.now())
dst = "dump/"+now
os.makedirs(dst);
os.makedirs(dst+'/composite');os.makedirs(dst+'/logscore');os.makedirs(dst+'/pxdisagree');os.makedirs(dst+'/globalblur');
os.makedirs(dst+'/variance');os.makedirs(dst+'/blur');os.makedirs(dst+'/lettercount');os.makedirs(dst+'/images');
os.makedirs(dst+'/pickle');
while cnt < 352:
MyRIPL.infer(100)
pflip = MyRIPL.report_value(self._pflip)
global_blur = MyRIPL.report_value(self._global_blur)
globalBlurArr.append(global_blur)
things = []
letter_count = 0
for i in range(MAX_LETTERS):
posx,posy,size_x,size_y,rotate_z,_id,blur,present = self.reportCharacters(chrs,i)
print present, pflip
if present == True:
letter_count += 1
things.append({'id':chr(int(_id)+65), 'size_x':size_x, 'size_y':size_y, 'rotate_z':rotate_z, 'left':posx, 'top':posy,'blur_sigsq':blur})
#print "left():",posx," top():", posy," size_x:", size_x, " size_y:", size_y, " rotate_z:", rotate_z,chr(_id+65)," blur: ",blur,"| pflip:", pflip, '\n'
blurArr[i].append(blur)
else:
blurArr[i].append(0)
cnt = cnt + 1
im = r.get_rendered_image(things,global_blur)
scipy.misc.imsave(dst+str('/images/')+str(cnt)+'.png', im)
logscore = MyRIPL.logscore()
logsArray.append(logscore['logscore'])
print 'LOGSCORE:', logscore, "|", cnt
diff = sum(abs(im-baselineIm))
pxdisagreeArr.append(diff)
pflipArr.append(pflip)
lettercountArr.append(letter_count)
###################################### PLOTTING HARNESS ############################################
self.composite(baselineIm,im,range(cnt),logsArray,pxdisagreeArr,globalBlurArr,pflipArr,dst+str('/composite/')+str(cnt)+'.png')
if cnt%30 == 0:
OBJ = {'logscore': logsArray, 'pxdisagree':pxdisagreeArr, 'variance':pflipArr, 'letter-count':lettercountArr, 'global-blur':globalBlurArr, 'letter-blur': blurArr }
pickle.dump(OBJ, open(dst+str('/pickle/')+str(cnt)+'.pkl','wb'))
self.savePlot(range(cnt),logsArray,"LOG-SCORE","Iterations","logscore", dst+str('/logscore/')+str(cnt)+'.png')
self.savePlot(range(cnt),pxdisagreeArr,"PX-DISAGREE","Iterations","pxdisagree", dst+str('/pxdisagree/')+str(cnt)+'.png')
self.savePlot(range(cnt),pflipArr,"VARIANCE","Iterations","variance", dst+str('/variance/')+str(cnt)+'.png')
self.savePlot(range(cnt),lettercountArr,"LETTER-COUNT","Iterations","letter count", dst+str('/lettercount/')+str(cnt)+'.png')
self.savePlot(range(cnt),globalBlurArr,"GLOBAL-BLUR","Iterations","blur", dst+str('/globalblur/')+str(cnt)+'.png')
for jj in range(MAX_LETTERS):
self.savePlot(range(cnt),blurArr[jj],"BLUR-LETTER-"+str(jj),"Iterations","blur", dst+str('/blur/')+str(cnt)+'_'+str(jj)+'.png')
