def get_synth_lib():
libSynth = FnLibrary()
A = PPSortVar('A')
B = PPSortVar('B')
C = PPSortVar('C')
tr5 = mkRealTensorSort([5])
tb5 = mkBoolTensorSort([5])
ti5 = mkIntTensorSort([5])
ppint = PPInt()
repeatEnum = PPEnumSort(10, 10)
libSynth.addItems([
PPLibItem('compose', func(func(B, C), func(A, B), func(A, C)), None),
PPLibItem('map_l', func(func(A, B), func(lst(A), lst(B))), None),
PPLibItem('fold_l', func(func(B, A, B), B, func(lst(A), B)), None),
PPLibItem('conv_l', func(func(lst(A), B), func(lst(A), lst(B))), None),
PPLibItem('conv_g', func(func(lst(A), B), func(graph(A), graph(B))),
None),
PPLibItem('map_g', func(func(A, B), func(graph(A), graph(B))), None),
PPLibItem('fold_g', func(func(B, A, B), B, func(graph(A), B)), None),
PPLibItem('zeros', func(PPDimVar('a'), mkRealTensorSort([1, 'a'])),
None),
PPLibItem('repeat', func(repeatEnum, func(A, A), func(A, A)), None),
PPLibItem(
'regress_speed_mnist',
func(mkRealTensorSort([1, 3, 32, 32]), mkRealTensorSort([1, 2])),
None),
# PPLibItem('nav_mnist', func(mkGraphSort(mkRealTensorSort([1, 3, 32, 32])),
# mkGraphSort(mkRealTensorSort([1, 2]))), None),
])
return libSynth
def getLib():
libSynth = FnLibrary()
A = PPSortVar('A')
B = PPSortVar('B')
C = PPSortVar('C')
tr5 = mkRealTensorSort([5])
tb5 = mkBoolTensorSort([5])
ti5 = mkIntTensorSort([5])
ppint = PPInt()
cnts = PPEnumSort(2, 50)
libSynth.addItems([
PPLibItem('map', func(func(A, B), func(lst(A), lst(B))), None),
PPLibItem('fold', func(func(B, A, B), B, func(lst(A), B)), None),
PPLibItem('conv', func(func(A, lst(A), A), func(lst(A), lst(A))),
None),
PPLibItem('compose', func(func(B, C), func(A, B), func(A, C)), None),
PPLibItem('repeat', func(cnts, func(A, A), func(A, A)), None),
PPLibItem('zeros', func(PPDimVar('a'), mkRealTensorSort([1, 'a'])),
None),
PPLibItem('nn_fun_0', func(tr5, tr5), None),
PPLibItem('nn_fun_1', func(tr5, tb5), None),
PPLibItem('nn_fun_2', func(tb5, ti5), None),
])
return libSynth
def getBaseLibrary():
libSynth = FnLibrary()
libSynth.addItems(
get_items_from_repo([
'compose', 'map_l', 'fold_l', 'conv_l', 'conv_g', 'map_g',
'fold_g', 'zeros', 'repeat'
]))
return libSynth
def mkDefaultLib():
lib = FnLibrary()
lib.addItems(
get_items_from_repo([
'compose',
# 'map_l', 'fold_l', 'conv_l',
'conv_g',
'map_g',
'fold_g',
'zeros',
'repeat'
]))
return lib
def test3():
t123 = mkTensorSort(PPInt(), [1, 2, 3])
t12 = mkTensorSort(PPInt(), [1, 2])
libSynth = FnLibrary()
libSynth.addItems([
PPLibItem('one', mkFuncSort(t123, t12), None),
])
ioExamples = None
fnSort = PPFuncSort([t123], t12)
interpreter = None
solver = SymbolicSynthesizer(interpreter, libSynth, fnSort, ioExamples)
solver.setEvaluate(False)
solution, score = solver.solve()
print(solution)
print(score)
def update_library(self, lib: FnLibrary,
task_result_single: TaskResultSingle, taskid):
if self.seq_settings.update_library:
# Add learned modules to the library
top_solution = task_result_single.get_top_solution_details()
if top_solution is not None:
prog, resDict = top_solution
unk_sort_map: Dict[str,
PPSort] = ASTUtils.getUnkNameSortMap(prog)
lib_items = [
PPLibItem(unk, unk_sort, resDict['new_fns_dict'][unk])
for unk, unk_sort in unk_sort_map.items()
]
if lib_items.__len__() > 0:
lib.addItems(lib_items)
# Save the library.
lib.save1(self.getLibLocation(), taskid)
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 test1():
intSort = PPInt()
boolSort = PPBool()
libSynth = FnLibrary()
libSynth.addItems([
PPLibItem('itob', mkFuncSort(intSort, boolSort), None),
])
ioExamples = None
fnSort = PPFuncSort([intSort], boolSort)
interpreter = None
solver = SymbolicSynthesizer(interpreter, libSynth, fnSort, ioExamples)
solver.setEvaluate(False)
targetProg = PPVar('lib.itobX')
count = solver.search(targetProg, 100)
assert count == -1
def xtest2():
intSort = PPInt()
boolSort = PPBool()
libSynth = FnLibrary()
libSynth.addItems([
PPLibItem('itob', mkFuncSort(intSort, boolSort), None),
])
ioExamples = None
fnSort = PPFuncSort([intSort], boolSort)
interpreter = None
solver = SymbolicSynthesizer(interpreter, libSynth, fnSort, ioExamples)
solver.setEvaluate(False)
targetProg = PPLambda(params=[PPVarDecl(name='x1', sort=PPInt())],
body=PPFuncApp(fn=PPVar('lib.itob'),
args=[PPVar(name='x1')]))
count = solver.search(targetProg, 100)
assert count >= 0
def test_zeros():
# IO Examples
train, val = split_into_train_and_validation(0, 10)
train_io_examples = get_batch_count_iseven(digits_to_count=[5],
count_up_to=10,
batch_size=100,
digit_dictionary=train)
val_io_examples = get_batch_count_iseven(digits_to_count=[5],
count_up_to=10,
batch_size=20,
digit_dictionary=val)
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
# Library
libSynth = FnLibrary()
t = PPSortVar('T')
t1 = PPSortVar('T1')
t2 = PPSortVar('T2')
libSynth.addItems([
PPLibItem('zeros', mkFuncSort(PPDimVar('a'),
mkRealTensorSort([1, 'a'])), pp_map),
# PPLibItem('zeros2', mkFuncSort(PPDimVar('a'), PPDimVar('b'), mkRealTensorSort(['a', 'b'])), pp_map),
])
fnSort = mkFuncSort(PPDimConst(2), mkRealTensorSort([2]))
interpreter = Interpreter(libSynth)
solver = SymbolicSynthesizer(interpreter, libSynth, fnSort,
train_io_examples, val_io_examples)
solver.setEvaluate(False)
solution, score = solver.solve()
def xtest4():
t123 = mkTensorSort(PPInt(), [1, 2, 3])
t333 = mkTensorSort(PPInt(), [3, 3, 3])
tabc = mkTensorSort(PPInt(), ['a', 'b', 'c'])
tabcc = mkTensorSort(PPInt(), ['a', 'b', 'c', 'd'])
tabcd = mkTensorSort(PPInt(), ['a', 'b', 'c', 'd'])
tddd = mkTensorSort(PPInt(), ['d', 'd', 'd'])
libSynth = FnLibrary()
libSynth.addItems([
PPLibItem('one', mkFuncSort(tabc, tabcc), None),
])
libSynth.addItems([
PPLibItem('two', mkFuncSort(tabcd, tddd), None),
])
ioExamples = None
fnSort = PPFuncSort([t123], t333)
interpreter = None
solver = SymbolicSynthesizer(interpreter, libSynth, fnSort, ioExamples)
solver.setEvaluate(False)
solution, score = solver.solve()
print(solution)
print(score)
def main():
for_realz = False
if for_realz:
data_size_tr = 6000
data_size_val = 2100
list_lengths_tr = [2, 3, 4, 5]
list_lengths_val = [6, 7, 8]
num_epochs = 20
else:
data_size_tr = 150 # 12000
data_size_val = 150 # 2100
list_lengths_tr = [1] # [2, 3, 4, 5]
list_lengths_val = [1] # [6, 7, 8]
num_epochs = 1 # 20
lib = FnLibrary()
addImageFunctionsToLibrary(lib, load_recognise_5s=False)
interpreter = Interpreter(
lib, batch_size=150,
epochs=num_epochs) #, evaluate_every_n_percent=70) # 60)
mnist_data_provider = MNISTDataProvider()
mnist_dict_train, mnist_dict_val, mnist_dict_test = mnist_data_provider.split_into_train_and_validation(
0, 12, shuffleFirst=True)
d1 = 1
io_examples_tr = mnist_data_provider.get_batch_count_var_len(
[d1],
data_size_tr,
mnist_dict_train,
list_lengths=list_lengths_tr,
return_count_int=False)
io_examples_val = mnist_data_provider.get_batch_count_var_len(
[d1],
data_size_val,
mnist_dict_val,
list_lengths=list_lengths_val,
return_count_int=False)
acc_np = []
acc_baseline = []
for i in range(10):
acc_np.append(
accuracy_test_np_model(interpreter, io_examples_tr,
io_examples_val))
acc_baseline.append(
accuracy_test_baseline_model(interpreter, io_examples_tr,
io_examples_val))
print("NP average error: {}".format(sum(acc_np) / len(acc_np)))
print("New average error: {}".format(
sum(acc_baseline) / len(acc_baseline)))
"""
def main(task_id, sequence_str, sequence_name):
# lib = mk_default_lib()
lib = FnLibrary()
addImageFunctionsToLibrary(lib, load_recognise_5s=False)
task_settings = get_task_settings(settings["dbg_mode"],
settings["dbg_learn_parameters"],
synthesizer=None)
seq_tasks_info = get_sequence_from_string(sequence_str)
print("running task {} of the following sequence:".format(task_id + 1))
print_sequence(seq_tasks_info)
interpreter = Interpreter(lib, batch_size=150, epochs=task_settings.epochs)
prefix = "{}_{}".format(sequence_name, task_id)
run_baseline_task(prefix, interpreter, task_settings,
seq_tasks_info[:task_id + 1])
def main(dir_path, type):
if for_realz:
settings = {
"data_size_tr": 6000,
"data_size_val": 2100,
"num_epochs": 30,
"training_data_percentages": [2, 10, 20, 50, 100]
}
else:
settings = {
"data_size_tr": 150,
"data_size_val": 150,
"num_epochs": 1,
"training_data_percentages": [100]
}
lib = FnLibrary()
addImageFunctionsToLibrary(lib, load_recognise_5s=False)
interpreter = Interpreter(lib,
batch_size=150,
epochs=settings["num_epochs"])
run_ss_classifier(interpreter, type, settings, dir_path)
run_ss_summer(interpreter, type, settings, dir_path)
def loadLibrary(libDirPath):
libFilePath = libDirPath + '/' + 'lib.pickle'
if not os.path.isfile(libFilePath):
return None
with open(libFilePath, 'rb') as fh:
libDict = pickle.load(fh)
lib = FnLibrary()
for name, (li, isNN) in libDict.items():
if isNN:
modelFilePath = libDirPath + '/' + name + '.pth'
obj = SaveableNNModule.create_and_load(libDirPath, name)
lib.addItem(PPLibItem(name, li, obj))
else:
lib.addItem(get_item_from_repo(name))
return lib
result["new_fns_dict"][name_conv_g].save(results_directory)
return result
if __name__ == '__main__':
results_dir = str(sys.argv[1])
# results_dir = "Results_maze_baselines"
if not os.path.exists(results_dir):
os.makedirs(results_dir)
just_testing = False
epochs_cnn = 1 # 000
epochs_nav = 10
batch_size = 150
lib = FnLibrary()
lib.addItems(
get_items_from_repo(
['flatten_2d_list', 'map_g', 'compose', 'repeat', 'conv_g']))
interpreter = Interpreter(lib, epochs=1, batch_size=batch_size)
# interpreter.epochs = epochs_cnn
# res1 = _train_s2t1(results_dir)
# print("res1: {}".format(res1["accuracy"]))
interpreter.epochs = epochs_nav
res2 = _train_s2t2(results_dir, "s2t1_cnn", "s2t1_mlp")
print("res2: {}".format(res2["accuracy"]))
interpreter.epochs = epochs_nav
res3 = _train_s2t3(results_dir, "s2t2_cnn", "s2t2_mlp", "s2t2_conv_g")
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)
def main():
io_train, io_val = get_io_examples_count_digit_occ(5, 1200, 1200)
# Task Name: count_digit_occ_5s
prog = PPFuncApp(
fn=PPVar(name='lib.compose'),
args=[
PPTermUnk(
name='nn_fun_3254',
sort=PPFuncSort(args=[
PPListSort(param_sort=PPListSort(param_sort=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.conv_l'),
args=[
PPFuncApp(fn=PPVar(name='lib.map_l'),
args=[PPVar(name='lib.nn_fun_1')])
])
])
unkSortMap = {
'nn_fun_3254':
PPFuncSort(args=[
PPListSort(param_sort=PPListSort(param_sort=PPTensorSort(
param_sort=PPBool(),
shape=[PPDimConst(
value=1), PPDimConst(value=1)])))
],
rtpe=PPTensorSort(
param_sort=PPReal(),
shape=[PPDimConst(value=1),
PPDimConst(value=1)]))
}
lib = FnLibrary()
lib.addItems([
PPLibItem(name='compose',
sort=PPFuncSort(args=[
PPFuncSort(args=[PPSortVar(name='B')],
rtpe=PPSortVar(name='C')),
PPFuncSort(args=[PPSortVar(name='A')],
rtpe=PPSortVar(name='B'))
],
rtpe=PPFuncSort(args=[PPSortVar(name='A')],
rtpe=PPSortVar(name='C'))),
obj=None),
PPLibItem(name='repeat',
sort=PPFuncSort(args=[
PPEnumSort(start=2, end=50),
PPFuncSort(args=[PPSortVar(name='A')],
rtpe=PPSortVar(name='A'))
],
rtpe=PPFuncSort(args=[PPSortVar(name='A')],
rtpe=PPSortVar(name='A'))),
obj=None),
PPLibItem(name='map_l',
sort=PPFuncSort(
args=[
PPFuncSort(args=[PPSortVar(name='A')],
rtpe=PPSortVar(name='B'))
],
rtpe=PPFuncSort(
args=[PPListSort(param_sort=PPSortVar(name='A'))],
rtpe=PPListSort(param_sort=PPSortVar(name='B')))),
obj=None),
PPLibItem(
name='fold_l',
sort=PPFuncSort(args=[
PPFuncSort(args=[PPSortVar(name='B'),
PPSortVar(name='A')],
rtpe=PPSortVar(name='B')),
PPSortVar(name='B')
],
rtpe=PPFuncSort(args=[
PPListSort(param_sort=PPSortVar(name='A'))
],
rtpe=PPSortVar(name='B'))),
obj=None),
PPLibItem(name='conv_l',
sort=PPFuncSort(
args=[
PPFuncSort(args=[
PPListSort(param_sort=PPSortVar(name='A'))
],
rtpe=PPSortVar(name='B'))
],
rtpe=PPFuncSort(
args=[PPListSort(param_sort=PPSortVar(name='A'))],
rtpe=PPListSort(param_sort=PPSortVar(name='B')))),
obj=None),
PPLibItem(name='zeros',
sort=PPFuncSort(args=[PPDimVar(name='a')],
rtpe=PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimVar(name='a')
])),
obj=None),
PPLibItem(name='nn_fun_1',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
])
],
rtpe=PPTensorSort(param_sort=PPBool(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
])),
obj=None),
PPLibItem(name='nn_fun_2230',
sort=PPFuncSort(args=[
PPTensorSort(param_sort=PPReal(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)
])
],
rtpe=PPTensorSort(param_sort=PPBool(),
shape=[
PPDimConst(value=1),
PPDimConst(value=1)
])),
obj=None)
])
fn_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)]))
print(ReprUtils.repr_py_ann(prog))
print(ReprUtils.repr_py_sort(lib.items['nn_fun_1'].sort))
NeuralSynthesizer.is_evaluable(prog)
def main():
tio, vio = get_io_examples_classify_digits(2000, 200)
# Task Name: classify_digits
prog = PPTermUnk(name='nn_fun_cs1cd_1', sort=PPFuncSort(args=[PPTensorSort(param_sort=PPReal(),
shape=[PPDimConst(value=1),
PPDimConst(value=1),
PPDimConst(value=28),
PPDimConst(value=28)])],
rtpe=PPTensorSort(param_sort=PPBool(),
shape=[PPDimConst(value=1),
PPDimConst(value=10)])))
unkSortMap = {'nn_fun_cs1cd_1': PPFuncSort(args=[PPTensorSort(param_sort=PPReal(),
shape=[PPDimConst(value=1), PPDimConst(value=1),
PPDimConst(value=28), PPDimConst(value=28)])],
rtpe=PPTensorSort(param_sort=PPBool(),
shape=[PPDimConst(value=1), PPDimConst(value=10)]))}
lib = FnLibrary()
lib.addItems([PPLibItem(name='compose', sort=PPFuncSort(
args=[PPFuncSort(args=[PPSortVar(name='B')], rtpe=PPSortVar(name='C')),
PPFuncSort(args=[PPSortVar(name='A')], rtpe=PPSortVar(name='B'))],
rtpe=PPFuncSort(args=[PPSortVar(name='A')], rtpe=PPSortVar(name='C'))), obj=None), PPLibItem(name='repeat',
sort=PPFuncSort(
args=[
PPEnumSort(
start=8,
end=10),
PPFuncSort(
args=[
PPSortVar(
name='A')],
rtpe=PPSortVar(
name='A'))],
rtpe=PPFuncSort(
args=[
PPSortVar(
name='A')],
rtpe=PPSortVar(
name='A'))),
obj=None),
PPLibItem(name='map_l',
sort=PPFuncSort(args=[PPFuncSort(args=[PPSortVar(name='A')], rtpe=PPSortVar(name='B'))],
rtpe=PPFuncSort(args=[PPListSort(param_sort=PPSortVar(name='A'))],
rtpe=PPListSort(param_sort=PPSortVar(name='B')))),
obj=None), PPLibItem(name='fold_l', sort=PPFuncSort(
args=[PPFuncSort(args=[PPSortVar(name='B'), PPSortVar(name='A')], rtpe=PPSortVar(name='B')),
PPSortVar(name='B')],
rtpe=PPFuncSort(args=[PPListSort(param_sort=PPSortVar(name='A'))], rtpe=PPSortVar(name='B'))), obj=None),
PPLibItem(name='conv_l', sort=PPFuncSort(
args=[PPFuncSort(args=[PPListSort(param_sort=PPSortVar(name='A'))], rtpe=PPSortVar(name='B'))],
rtpe=PPFuncSort(args=[PPListSort(param_sort=PPSortVar(name='A'))],
rtpe=PPListSort(param_sort=PPSortVar(name='B')))), obj=None),
PPLibItem(name='zeros', sort=PPFuncSort(args=[PPDimVar(name='a')],
rtpe=PPTensorSort(param_sort=PPReal(),
shape=[PPDimConst(value=1),
PPDimVar(name='a')])), obj=None)])
fn_sort = PPFuncSort(args=[PPTensorSort(param_sort=PPReal(),
shape=[PPDimConst(value=1), PPDimConst(value=1), PPDimConst(value=28),
PPDimConst(value=28)])],
rtpe=PPTensorSort(param_sort=PPBool(), shape=[PPDimConst(value=1), PPDimConst(value=10)]))
interpreter = Interpreter(lib, 150)
res = interpreter.evaluate(program=prog,
output_type_s=fn_sort.rtpe,
unkSortMap=unkSortMap,
io_examples_tr=tio,
io_examples_val=vio)
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()