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 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 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 test_synthesizer_count_5s(): libSynth = getLib() tr1_1_28_28 = mkRealTensorSort([1, 1, 28, 28]) tr1_1 = mkRealTensorSort([1, 1]) tb1_1 = mkBoolTensorSort([1, 1]) libSynth.addItems([ PPLibItem('recog_5', func(tr1_1_28_28, tb1_1), None), ]) fn_sort = func(lst(tr1_1_28_28), tr1_1) 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 __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 __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 __init__(self, settings, toy, seq, dbg_learn_parameters): input_type = mkRealTensorSort([1, 1, 28, 28]) output_type = mkBoolTensorSort([1, 1]) fn_sort = mkFuncSort(input_type, output_type) self.toy = toy super(RecognizeToyTask, self).__init__(fn_sort, settings, seq, dbg_learn_parameters)
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 _mkNSynth(self): ea_synthesis_mode = self.settings.synthesizer == 'evolutionary' interpreter = Interpreter(self.seq.lib, epochs=self.settings.epochs, batch_size=self.settings.batch_size) nnprefix = self.seq.sname() + self.sname() if self.settings.synthesizer == 'enumerative': # concrete_types = [mkRealTensorSort([1, 64, 4, 4]), mkRealTensorSort([1, 50])] concreteTypes = [ mkRealTensorSort([1, 64, 4, 4]), mkBoolTensorSort([1, 1]), mkRealTensorSort([1, 50]) ] synth = SymbolicSynthesizer(self.seq.lib, self.fn_sort, nnprefix, concreteTypes) ns_settings = NeuralSynthesizerSettings(self.settings.N, self.settings.M, self.settings.K) assert self.seq.lib is not None nsynth = NeuralSynthesizer(interpreter, synth, self.seq.lib, self.fn_sort, self.settings.dbg_learn_parameters, ns_settings) return nsynth elif self.settings.synthesizer == 'evolutionary': concreteTypes = [ mkRealTensorSort([1, 64, 4, 4]), mkBoolTensorSort([1, 1]), mkRealTensorSort([1, 50]) ] synth = SymbolicSynthesizerEA(self.seq.lib, self.fn_sort, nnprefix, concreteTypes) # TODO: Do not hardcode G NUM_GENERATIIONS = 100 ns_settings = NeuralSynthesizerEASettings(G=NUM_GENERATIIONS, M=self.settings.M, K=self.settings.K) assert self.seq.lib is not None nsynth = NeuralSynthesizerEA(interpreter, synth, self.seq.lib, self.fn_sort, ns_settings) return nsynth
def test_synthesizer_graph(): libSynth = get_synth_lib() input_type = mkGraphSort(mkRealTensorSort([1, 3, 32, 32])) output_type = mkGraphSort(mkRealTensorSort([1, 2])) fn_sort = mkFuncSort(input_type, output_type) synth = SymbolicSynthesizer(libSynth, fn_sort) I = 20 i = 0 for prog, unkMap in synth.genProgs(): if i > I: break if NeuralSynthesizer.is_evaluable(prog)[0]: i = i + 1 # print(i, repr_py_ann(prog)) print(i, repr_py(prog))
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 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 main(): input_type = mkRealTensorSort([1, 1, 28, 28]) output_type = mkBoolTensorSort([1, 1]) fn_sort = mkFuncSort(input_type, output_type) lib = mkDefaultLib() pg = ProgramGenerator(lib) progs = [] while len(progs) < 30: prog = pg.genProg(fn_sort) if prog is not None and prog not in progs: print(repr_py(prog)) progs.append(prog) else: pass
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 add_libitems_to_repo(): def func(*lst): return mkFuncSort(*lst) def lst(t): return mkListSort(t) A = PPSortVar('A') B = PPSortVar('B') C = PPSortVar('C') real_tensor_2d = mkTensorSort(PPReal(), ['a', 'b']) bool_tensor_2d = mkTensorSort(PPBool(), ['a', 'b']) add_lib_item( PPLibItem('compose', func(func(B, C), func(A, B), func(A, C)), pp_compose)) add_lib_item( PPLibItem('repeat', func(PPEnumSort(9, 10), func(A, A), func(A, A)), pp_repeat)) add_lib_item( PPLibItem('map_l', func(func(A, B), func(lst(A), lst(B))), pp_map_list)) add_lib_item( PPLibItem('fold_l', func(func(B, A, B), B, func(lst(A), B)), pp_reduce_list)) add_lib_item( PPLibItem('conv_l', func(func(lst(A), B), func(lst(A), lst(B))), pp_conv_list)) add_lib_item( PPLibItem('zeros', func(PPDimVar('a'), mkRealTensorSort([1, 'a'])), pp_get_zeros)) def graph(t): return mkGraphSort(t) add_lib_item( PPLibItem('conv_g', func(func(lst(A), B), func(graph(A), graph(B))), pp_conv_graph)) add_lib_item( PPLibItem('map_g', func(func(A, B), func(graph(A), graph(B))), pp_map_g)) add_lib_item( PPLibItem('fold_g', func(func(B, A, B), B, func(graph(A), B)), pp_reduce_graph)) add_lib_item( PPLibItem('flatten_2d_list', func(func(B, C), func(A, B), func(A, C)), pp_flatten_2d_list))
def addRecogFive2(lib): inType = mkRealTensorSort([1, 1, 28, 28]) outType = mkBoolTensorSort([1, 1]) recogDigitType = mkFuncSort(inType, outType) lib.addItem(PPLibItem('recogFive2', recogDigitType, None))
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 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 test_count_5s(): libSynth = getLib() tr1_1_28_28 = mkRealTensorSort([1, 1, 28, 28]) tr1_1 = mkRealTensorSort([1, 1]) tb1_1 = mkBoolTensorSort([1, 1]) libSynth.addItems([ PPLibItem('recog_5', func(tr1_1_28_28, tb1_1), None), ]) fn_sort = func(lst(tr1_1_28_28), tr1_1) 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, 'recog_5') 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=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'), args=[PPVar(name='lib.recog_5')]) ])) printTerm(t)
def test_fold(): tr15 = mkRealTensorSort([1, 5]) tb51 = mkBoolTensorSort([1, 5]) ti15 = mkIntTensorSort([1, 5]) libSynth = getLib() t = PPTermNT("Z", func(lst(tr15), tr15)) printTerm(t) # (Z: (List[Tensor[real][1,5]] --> Tensor[real][1,5])) t = Rules.expandToFuncApp(libSynth, t, 1, 'fold') assert (t == PPFuncApp( fn=PPVar(name='lib.fold'), args=[ PPTermNT(name='Z', sort=PPFuncSort(args=[ PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]), PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]) ], rtpe=PPTensorSort(param_sort=PPReal(), shape=[ PPDimConst(value=1), PPDimConst(value=5) ]))), PPTermNT(name='Z', sort=PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)])) ])) printTerm(t) # lib.fold((Z: ((Tensor[real][1,5], Tensor[real][1,5]) --> Tensor[real][1,5])), (Z: Tensor[real][1,5])) t = Rules.expandToFuncApp(libSynth, t, 2, 'zeros') assert (t == PPFuncApp( fn=PPVar(name='lib.fold'), args=[ PPTermNT(name='Z', sort=PPFuncSort(args=[ PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]), PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]) ], rtpe=PPTensorSort(param_sort=PPReal(), shape=[ PPDimConst(value=1), PPDimConst(value=5) ]))), PPFuncApp(fn=PPVar(name='lib.zeros'), args=[PPTermNT(name='Z', sort=PPDimConst(value=5))]) ])) printTerm(t) # lib.fold((Z: ((Tensor[real][1,5], Tensor[real][1,5]) --> Tensor[real][1,5])), lib.zeros((Z: 5))) t = Rules.expandDimConst(t, 2) assert (t == PPFuncApp( fn=PPVar(name='lib.fold'), args=[ PPTermNT(name='Z', sort=PPFuncSort(args=[ PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]), PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]) ], rtpe=PPTensorSort(param_sort=PPReal(), shape=[ PPDimConst(value=1), PPDimConst(value=5) ]))), PPFuncApp(fn=PPVar(name='lib.zeros'), args=[PPIntConst(value=5)]) ])) printTerm(t) # lib.fold((Z: ((Tensor[real][1,5], Tensor[real][1,5]) --> Tensor[real][1,5])), lib.zeros(5)) t = Rules.expandToUnk(t, 1) assert (t == PPFuncApp( fn=PPVar(name='lib.fold'), args=[ PPTermUnk(name='Unk', sort=PPFuncSort(args=[ PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]), PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=1), PPDimConst(value=5)]) ], rtpe=PPTensorSort( param_sort=PPReal(), shape=[ PPDimConst(value=1), PPDimConst(value=5) ]))), PPFuncApp(fn=PPVar(name='lib.zeros'), args=[PPIntConst(value=5)]) ])) printTerm(t)
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 tr5 = mkRealTensorSort([5]) tb5 = mkBoolTensorSort([5]) ti5 = mkIntTensorSort([5]) def test_repeat(): libSynth = getLib() t = PPTermNT("Z", func(tr5, tr5)) assert (t == PPTermNT(name='Z', sort=PPFuncSort(args=[ PPTensorSort(param_sort=PPReal(), shape=[PPDimConst(value=5)]) ], rtpe=PPTensorSort( param_sort=PPReal(), shape=[PPDimConst(value=5)]))))
def getSort(): inType = mkListSort(mkRealTensorSort([1, 1, 28, 28])) outType = mkRealTensorSort([1, 1]) return mkFuncSort(inType, outType)
def test_search_space(): # type shortcuts timg = mkRealTensorSort([1, 1, 28, 28]) treal = mkRealTensorSort([1, 1]) tbool = mkBoolTensorSort([1, 1]) tbool10 = mkBoolTensorSort([1, 10]) treal2 = mkRealTensorSort([1, 2]) def mklst(t): return mkListSort(t) def mkfn(t1, t2): return mkFuncSort(t1, t2) def mkgr(t): return mkGraphSort(t) targetSize = 6 print('start') print('targetSize = %d' % targetSize) add_sort = mkFuncSort(treal, tbool, treal) testSeqs = ['cs1'] if 'cs1' in testSeqs: sname = 'cs1' libSynth = getBaseLibrary() tname = sname + '_recog_digit_d1' print(tname) fn_sort = mkfn(timg, tbool) print_progs(fn_sort, libSynth, targetSize) lfn = fn_sort add_to_lib(lfn, libSynth, tname) tname = sname + '_recog_digit_d2' print(tname) fn_sort = mkfn(timg, tbool) print_progs(fn_sort, libSynth, targetSize) lfn = fn_sort add_to_lib(lfn, libSynth, tname) tname = sname + '_count_digit_d1' print(tname) fn_sort = mkfn(mklst(timg), treal) print_progs(fn_sort, libSynth, targetSize) lfn = add_sort add_to_lib(lfn, libSynth, 'nn_add') tname = sname + '_count_digit_d2' print(tname) fn_sort = mkfn(mklst(timg), treal) print_progs(fn_sort, libSynth, targetSize) if 'cs2' in testSeqs: sname = 'cs2' libSynth = getBaseLibrary() tname = sname + '_recog_digit_d1' print(tname) fn_sort = mkfn(timg, tbool) print_progs(fn_sort, libSynth, targetSize) lfn = fn_sort add_to_lib(lfn, libSynth, tname) tname = sname + '_count_digit_d1' print(tname) fn_sort = mkfn(mklst(timg), treal) print_progs(fn_sort, libSynth, targetSize) lfn = add_sort add_to_lib(fn_sort, libSynth, 'nn_add') tname = sname + '_count_digit_d2' print(tname) fn_sort = mkfn(mklst(timg), treal) print_progs(fn_sort, libSynth, targetSize) lfn = mkfn(timg, tbool) add_to_lib(fn_sort, libSynth, 'nn_recog_digit_d2') tname = sname + '_recog_digit_d2' print(tname) fn_sort = mkfn(timg, tbool) print_progs(fn_sort, libSynth, targetSize) if 'ss' in testSeqs: sname = 'ss' libSynth = getBaseLibrary() tname = sname + '_classify_digit' print(tname) fn_sort = mkfn(timg, tbool10) print_progs(fn_sort, libSynth, targetSize) lfn = fn_sort add_to_lib(fn_sort, libSynth, tname) tname = sname + '_sum_digits' print(tname) fn_sort = mkfn(mklst(timg), treal) print_progs(fn_sort, libSynth, targetSize) if 'gs1' in testSeqs: sname = 'gs1' libSynth = getBaseLibrary() tname = sname + '_regress_speed' print(tname) fn_sort = mkfn(timg, treal2) print_progs(fn_sort, libSynth, targetSize) lfn = fn_sort add_to_lib(fn_sort, libSynth, tname) tname = sname + '_shortest_path_street' print(tname) fn_sort = mkfn(mkgr(timg), mkgr(treal2)) print_progs(fn_sort, libSynth, targetSize) if 'gs2' in testSeqs: sname = 'gs2' libSynth = getBaseLibrary() tname = sname + '_regress_mnist' print(tname) fn_sort = mkfn(timg, treal2) # print_progs(fn_sort, libSynth, targetSize) lfn = fn_sort add_to_lib(lfn, libSynth, tname) tname = sname + '_shortest_path_mnist' print(tname) fn_sort = mkfn(mkgr(timg), mkgr(treal2)) # print_progs(fn_sort, libSynth, targetSize) lfn = mkfn(mklst(treal2), treal2) add_to_lib(lfn, libSynth, 'nn_relax') tname = sname + '_shortest_path_street' print(tname) fn_sort = mkfn(mkgr(timg), mkgr(treal2)) print_progs(fn_sort, libSynth, targetSize)