def testMutate0():
lib = mkDefaultLib()
# region #+ Add recogFive to library
inType = mkRealTensorSort([1, 1, 28, 28])
outType = mkBoolTensorSort([1, 1])
recogDigitType = mkFuncSort(inType, outType)
lib.addItem(PPLibItem('recogFive', recogDigitType, None))
# endregion
inType = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
outType = mkListSort(mkBoolTensorSort([1, 1]))
sort = mkFuncSort(inType, outType)
prog = PPFuncApp(fn=PPVar(name='lib.map_l'),
args=[PPVar(name='lib.recogFive')])
for i in range(100):
newProg = mutate(prog, lib)
if newProg is None:
continue
print(repr_py(newProg))
isort = inferType(newProg, lib)
assert isort is not None
assert sort == isort
def __init__(self, settings, toy_class, seq, dbg_learn_parameters):
input_type = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
output_type = mkRealTensorSort([1, 1])
fn_sort = mkFuncSort(input_type, output_type)
super(CountToysTask, self).__init__(fn_sort, settings, seq, dbg_learn_parameters)
self.toy_class = toy_class
def testMutate2():
"""
Unkprog
"""
lib = mkDefaultLib()
addRecogFive(lib)
inType = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
outType = mkRealTensorSort([1, 1])
sort = mkFuncSort(inType, outType)
prog = \
PPTermUnk(name='nn_fun_x_906', sort=sort)
for i in range(100):
newProg = mutate(prog, lib)
if newProg is None:
continue
# print(repr_py(newProg))
# print('newProg: ', newProg)
# print('newProgReprPy: ', repr_py(newProg))
isort = inferType(newProg, lib)
if isort is None:
print(repr_py(newProg))
print('newProg: ', newProg)
continue
assert sort == isort
def test5():
def mk_recognise_5s():
res = NetCNN("recognise_5s",
input_ch=1,
output_dim=1,
output_activation=F.sigmoid)
res.load('../Interpreter/Models/is5_classifier.pth.tar')
return res
libSynth = FnLibrary()
t = PPSortVar('T')
t1 = PPSortVar('T1')
t2 = PPSortVar('T2')
libSynth.addItems([
PPLibItem(
'recognise_5s',
mkFuncSort(mkTensorSort(PPReal(), ['a', 1, 28, 28]),
mkTensorSort(PPReal(), ['a', 1])), mk_recognise_5s()),
PPLibItem(
'map',
mkFuncSort(mkFuncSort(t1, t2), mkListSort(t1), mkListSort(t2)),
pp_map),
])
ioExamples = None
img = mkRealTensorSort([1, 1, 28, 28])
imgList = mkListSort(img)
isFive = mkRealTensorSort([1, 1])
imgToIsFive = mkFuncSort(img, isFive)
isFiveList = mkListSort(isFive)
fnSort = mkFuncSort(imgList, isFiveList)
interpreter = None
"""targetProg = lambda inputs: map(lib.recognise_5s, inputs)"""
solver = SymbolicSynthesizer(interpreter, libSynth, fnSort, ioExamples,
ioExamples)
solver.setEvaluate(False)
# TODO: use "search" instead of "solve"
solution, score = solver.solve()
print(solution)
print(score)
def __init__(self, settings, digit, seq, dbg_learn_parameters):
input_type = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
# input_type = mkListSort(mkBoolTensorSort([1, 1]))
# input_type = mkBoolTensorSort([1, 1])
output_type = mkRealTensorSort([1, 1])
fn_sort = mkFuncSort(input_type, output_type)
super(CountDigitOccTask, self).__init__(fn_sort, settings, seq, dbg_learn_parameters)
self.digit = digit
def main():
try:
# s1 = mkIntTensorSort(['A', 3])
# print(ntstr(s1))
#
# t1 = mkIntTensorSort([2, 'B'])
# print(ntstr(t1))
#
# subst = unifyLists([s1], [t1])
# for x, y in subst:
# print("%s ---> %s" % (ntstr(x), ntstr(y)))
t1 = PPSortVar('T1')
t2 = PPSortVar('T2')
s = PPSortVar('S')
x = mkFuncSort(mkFuncSort(t1, t2), mkListSort(t1), mkListSort(t2))
y = mkFuncSort(mkFuncSort(s, s), mkListSort(s), mkListSort(s))
displayUnifyListH([x], [y])
except:
print("exception")
raise
def testMutate1():
lib = mkDefaultLib()
addRecogFive(lib)
inType = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
outType = mkRealTensorSort([1, 1])
sort = mkFuncSort(inType, outType)
prog = \
PPFuncApp(fn=PPVar(name='lib.compose'),
args=[PPFuncApp(fn=PPVar(name='lib.fold_l'),
args=[PPTermUnk(name='nn_fun_x_906',
sort=PPFuncSort(
args=[PPTensorSort(param_sort=PPReal(),
shape=[PPDimConst(value=1),
PPDimConst(value=1)]),
PPTensorSort(param_sort=PPBool(),
shape=[PPDimConst(value=1),
PPDimConst(value=1)])],
rtpe=PPTensorSort(param_sort=PPReal(),
shape=[PPDimConst(value=1),
PPDimConst(value=1)]))),
PPFuncApp(fn=PPVar(name='lib.zeros'), args=[PPIntConst(value=1)])]),
PPFuncApp(fn=PPVar(name='lib.map_l'), args=[PPVar(name='lib.recogFive')])])
for i in range(100):
newProg = mutate(prog, lib)
if newProg is None:
continue
# print(repr_py(newProg))
# print('newProg: ', newProg)
# print('newProgReprPy: ', repr_py(newProg))
isort = inferType(newProg, lib)
if isort is None:
print(repr_py(newProg))
print('newProg: ', newProg)
continue
assert sort == isort
def test_synthesizer_sum_digits():
libSynth = getLib()
input_type = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
output_type = mkRealTensorSort([1, 1])
fn_sort = mkFuncSort(input_type, output_type)
tr1_1_28_28 = mkRealTensorSort([1, 1, 28, 28])
tb_1_10 = mkBoolTensorSort([1, 10])
classify_digit = mkFuncSort(tr1_1_28_28, tb_1_10)
libSynth.addItems([
PPLibItem('classify_digit', classify_digit, None),
])
synth = SymbolicSynthesizer(libSynth, fn_sort)
I = 10000
i = 0
for prog, unkMap in synth.genProgs():
i = i + 1
if i > I:
break
if i % 100 == 0:
print(i)
unks = ASTUtils.getUnks(prog)
if len(unks) > 1:
continue
for unk in unks:
if ASTUtils.isAbstract(unk.sort):
continue
print(repr_py_ann(prog))
def lst(t):
return mkListSort(t)
def addImageFunctionsToLibrary(libSynth: FnLibrary, load_recognise_5s=True):
real_tensor_2d = mkTensorSort(PPReal(), ['a', 'b'])
bool_tensor_2d = mkTensorSort(PPBool(), ['a', 'b'])
libSynth.addItems([
PPLibItem('add',
mkFuncSort(real_tensor_2d, real_tensor_2d, real_tensor_2d),
pp_add),
PPLibItem('add1',
mkFuncSort(real_tensor_2d, bool_tensor_2d, real_tensor_2d),
pp_add),
PPLibItem(
'map',
mkFuncSort(mkFuncSort(t1, t2), mkListSort(t1), mkListSort(t2)),
pp_map),
PPLibItem(
'map2d',
mkFuncSort(mkFuncSort(t1, t2), mkListSort(mkListSort(t1)),
mkListSort(mkListSort(t2))), pp_map2d),
# question ^ should we transform map's definition into using vectors? is this not enough?
# we don't know the type of the tensor output, w/o knowing the function.
# PPLibItem('cat', mkFuncSort(mkTensorSort(PPReal(), ['a', 'b']), mkTensorSort(PPReal(), ['a', 'c']),
# mkTensorSort(PPReal(), ['a', 'd'])), pp_cat), # TODO: d = b + c
# Question: can we write 'b+c'? I'm not sure if it's useful
# Also, the input types don't have to be PPReal, but for not it should suffice to just leave it like this?
# ^ It can accept a tuple of tensors of different shapes, but maybe we can restrict it to tuple of 2 for now.
# PPLibItem('zeros', mkFuncSort(PPInt(), mkTensorSort(PPReal(), ['a', 'b']), mkTensorSort(PPReal(), ['a', 'c'])), pp_get_zeros),
# PPLibItem('zeros', mkFuncSort(PPInt(), PPInt(), mkTensorSort(PPReal(), ['a', 'c'])), pp_get_zeros),
# 4, [2, 5] -> [2, 4]
# 7, [2, 5] -> [2, 7]
# Question: How do we say that the ints are the same number, PPInt() == 'c'
# Also, The input tensor type doesn't have to be PPReal, can be int or bool as well
# Also, the input tensor can be of any type, doesn't need to be float
PPLibItem('zeros', mkFuncSort(PPDimVar('a'), mkRealTensorSort([1,
'a'])),
pp_get_zeros),
PPLibItem('reduce_general',
mkFuncSort(mkFuncSort(t, t1, t), mkListSort(t1), t, t),
pp_reduce),
PPLibItem('reduce', mkFuncSort(mkFuncSort(t, t, t), mkListSort(t), t),
pp_reduce),
# pp_get_zeros
# PPLibItem('reduce_with_init_zeros', mkFuncSort(mkFuncSort(t, t1, t), mkListSort(t1), t), pp_reduce_w_zeros_init),
# Question : the initializer is only optional. How do we encode this information?
# The following are just test functions for evaluation, not properly typed.
# ,PPLibItem('mult_range09', mkFuncSort(mkFuncSort(t, t1, t), mkListSort(t1), t, t), get_multiply_by_range09())
# ,PPLibItem('argmax', mkFuncSort(mkFuncSort(t, t1, t), mkListSort(t1), t, t), argmax)
# PPLibItem('split', mkFuncSort(PPImageSort(), mkListSort(PPImageSort())), split),
# PPLibItem('join', mkFuncSort(mkListSort(PPImageSort()), PPImageSort()), None),
])
if load_recognise_5s:
libSynth.addItems([
PPLibItem(
'recognise_5s',
mkFuncSort(mkTensorSort(PPReal(), ['a', 1, 28, 28]),
mkTensorSort(PPBool(), ['a', 1])),
mk_recognise_5s())
])
# set the neural libraries to evaluation mode
# TODO: need to make sure we're properly switching between eval and train everywhere
libSynth.recognise_5s.eval()
def test_sum_digits():
libSynth = getLib()
input_type = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
output_type = mkRealTensorSort([1, 1])
fn_sort = mkFuncSort(input_type, output_type)
tr1_1_28_28 = mkRealTensorSort([1, 1, 28, 28])
tb_1_10 = mkBoolTensorSort([1, 10])
classify_digit = mkFuncSort(tr1_1_28_28, tb_1_10)
libSynth.addItems([
PPLibItem('classify_digit', classify_digit, None),
])
t = PPTermNT("Z", fn_sort)
assert (t == PPTermNT(
name='Z',
sort=PPFuncSort(args=[
PPListSort(param_sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
]))
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[PPDimConst(value=1),
PPDimConst(value=1)]))))
printTerm(t)
# (Z: (List[Tensor[real][1,1,28,28]] --> Tensor[real][1,1]))
t = Rules.expandToFuncApp(libSynth, t, 1, 'compose')
assert (t == PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPTermNT(name='Z',
sort=PPFuncSort(args=[PPSortVar(name='B')],
rtpe=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))),
PPTermNT(name='Z',
sort=PPFuncSort(args=[
PPListSort(
param_sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
]))
],
rtpe=PPSortVar(name='B')))
]))
printTerm(t)
# lib.compose((Z: (B --> Tensor[real][1,1])), (Z: (List[Tensor[real][1,1,28,28]] --> B)))
t = Rules.expandToFuncApp(libSynth, t, 1, 'fold')
assert (t == PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPFuncApp(fn=PPVar(name='lib.fold'),
args=[
PPTermNT(name='Z',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]),
PPSortVar(name='A')
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))),
PPTermNT(name='Z',
sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))
]),
PPTermNT(name='Z',
sort=PPFuncSort(args=[
PPListSort(
param_sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
]))
],
rtpe=PPListSort(param_sort=PPSortVar(
name='A'))))
]))
printTerm(t)
# lib.compose(lib.fold((Z: ((Tensor[real][1,1], A) --> Tensor[real][1,1])), (Z: Tensor[real][1,1])), (Z: (List[Tensor[real][1,1,28,28]] --> List[A])))
t = Rules.expandToUnk(t, 1)
assert (t == PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPFuncApp(fn=PPVar(name='lib.fold'),
args=[
PPTermUnk(
name='Unk',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]),
PPSortVar(name='A')
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))),
PPTermNT(name='Z',
sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))
]),
PPTermNT(name='Z',
sort=PPFuncSort(args=[
PPListSort(
param_sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
]))
],
rtpe=PPListSort(param_sort=PPSortVar(
name='A'))))
]))
printTerm(t)
# lib.compose(lib.fold((Unk: ((Tensor[real][1,1], A) --> Tensor[real][1,1])), (Z: Tensor[real][1,1])), (Z: (List[Tensor[real][1,1,28,28]] --> List[A])))
t = Rules.expandToFuncApp(libSynth, t, 1, 'zeros')
assert (t == PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPFuncApp(
fn=PPVar(name='lib.fold'),
args=[
PPTermUnk(name='Unk',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]),
PPSortVar(name='A')
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))),
PPFuncApp(
fn=PPVar(name='lib.zeros'),
args=[PPTermNT(name='Z', sort=PPDimConst(value=1))])
]),
PPTermNT(name='Z',
sort=PPFuncSort(args=[
PPListSort(
param_sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
]))
],
rtpe=PPListSort(param_sort=PPSortVar(
name='A'))))
]))
printTerm(t)
# lib.compose(lib.fold((Unk: ((Tensor[real][1,1], A) --> Tensor[real][1,1])), lib.zeros((Z: 1))), (Z: (List[Tensor[real][1,1,28,28]] --> List[A])))
t = Rules.expandDimConst(t, 1)
assert (t == PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPFuncApp(fn=PPVar(name='lib.fold'),
args=[
PPTermUnk(
name='Unk',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]),
PPSortVar(name='A')
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))),
PPFuncApp(fn=PPVar(name='lib.zeros'),
args=[PPIntConst(value=1)])
]),
PPTermNT(name='Z',
sort=PPFuncSort(args=[
PPListSort(
param_sort=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
]))
],
rtpe=PPListSort(param_sort=PPSortVar(
name='A'))))
]))
printTerm(t)
# lib.compose(lib.fold((Unk: ((Tensor[real][1,1], A) --> Tensor[real][1,1])), lib.zeros(1)), (Z: (List[Tensor[real][1,1,28,28]] --> List[A])))
t = Rules.expandToFuncApp(libSynth, t, 1, 'map')
assert (t == PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPFuncApp(fn=PPVar(name='lib.fold'),
args=[
PPTermUnk(
name='Unk',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]),
PPSortVar(name='B')
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))),
PPFuncApp(fn=PPVar(name='lib.zeros'),
args=[PPIntConst(value=1)])
]),
PPFuncApp(fn=PPVar(name='lib.map'),
args=[
PPTermNT(name='Z',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
])
],
rtpe=PPSortVar(name='B')))
])
]))
printTerm(t)
# lib.compose(lib.fold((Unk: ((Tensor[real][1,1], B) --> Tensor[real][1,1])), lib.zeros(1)), lib.map((Z: (Tensor[real][1,1,28,28] --> B))))
t = Rules.expandToVar(libSynth, t, 1, 'classify_digit')
assert (t == PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPFuncApp(fn=PPVar(name='lib.fold'),
args=[
PPTermUnk(
name='Unk',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]),
PPTensorSort(param_sort=PPBool(),
shape=[
PPDimConst(value=1),
PPDimConst(value=10)
])
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
]))),
PPFuncApp(fn=PPVar(name='lib.zeros'),
args=[PPIntConst(value=1)])
]),
PPFuncApp(fn=PPVar(name='lib.map'),
args=[PPVar(name='lib.classify_digit')])
]))
printTerm(t)
def getSort():
inType = mkListSort(mkRealTensorSort([1, 1, 28, 28]))
outType = mkRealTensorSort([1, 1])
return mkFuncSort(inType, outType)
def mklst(t):
return mkListSort(t)
def test6():
t = PPSortVar('T')
t1 = PPSortVar('T1')
t2 = PPSortVar('T2')
def mk_recognise_5s():
res = NetCNN("recognise_5s",
input_ch=1,
output_dim=1,
output_activation=F.sigmoid)
res.load('../Interpreter/Models/is5_classifier.pth.tar')
return res
libSynth = FnLibrary()
real_tensor_2d = mkTensorSort(PPReal(), ['a', 'b'])
libSynth.addItems([
PPLibItem(
'recognise_5s',
mkFuncSort(mkTensorSort(PPReal(), ['a', 1, 28, 28]),
mkTensorSort(PPReal(), ['a', 1])), mk_recognise_5s()),
PPLibItem(
'map',
mkFuncSort(mkFuncSort(t1, t2), mkListSort(t1), mkListSort(t2)),
pp_map),
PPLibItem('reduce', mkFuncSort(mkFuncSort(t, t, t), mkListSort(t), t),
pp_reduce),
PPLibItem('add',
mkFuncSort(real_tensor_2d, real_tensor_2d, real_tensor_2d),
lambda x, y: x + y),
])
train, val = split_into_train_and_validation(0, 10)
val_ioExamples = get_batch_count_iseven(digits_to_count=[5],
count_up_to=10,
batch_size=20,
digit_dictionary=val)
img = mkRealTensorSort([1, 1, 28, 28])
isFive = mkRealTensorSort([1, 1])
imgToIsFive = mkFuncSort(img, isFive)
imgList = mkListSort(img)
isFiveList = mkListSort(isFive)
sumOfFives = mkRealTensorSort([1, 1])
fnSort = mkFuncSort(imgList, sumOfFives)
interpreter = Interpreter(libSynth)
"""
targetProg =
lambda inputs.
reduce(
add,
map(lib.recognise_5s, inputs))
"""
# TODO: use "search" instead of "solve"
solver = SymbolicSynthesizer(interpreter, libSynth, fnSort, val_ioExamples,
val_ioExamples)
# solver.setEvaluate(False)
solution, score = solver.solve()
print(solution)
print(score)