def print_progs_e(fn_sort, libSynth, targetSize): synth = SymbolicSynthesizer(libSynth, fn_sort) cnt = 1 ecnt = 1 for prog, unkMap in synth.genProgs(): sz = ASTUtils.getSize2(prog) if sz > targetSize: break res, code = NeuralSynthesizer.is_evaluable(prog, fn_sort) if res: if 'lib.compose(lib.repeat(10, lib.conv_g(lib.nn_relax))' in repr_py( prog): print('.', cnt, sz, repr_py(prog), ecnt) ecnt += 1 else: if 'lib.compose(lib.repeat(10, lib.conv_g(lib.nn_relax))' in repr_py( prog): print("#", cnt, sz, repr_py(prog), code) test = False if test: res, code = NeuralSynthesizer.is_evaluable(prog, fn_sort) # print(cnt, sz, prog) cnt += 1 print(cnt)
def onEachIteration(self, st: PPTerm, action: Action): return None print("------------") print(repr_py(st)) print(st) print("Action: (%d, %d)" % (action.ntId, action.ruleId))
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_progs(self): n = 0 m = 0 pStart = time.time() print('BEGIN_PROGRAM_GENERATION, Time: %s' % getElapsedTime()) for prog, unkSortMap in self.synthesizer.genProgs(): n += 1 if n % 100 == 0: print('.', end='', flush=True) if n > self.settings.N or m >= self.settings.M: break c_program_str_representation = repr_py(prog) try: is_ok, ecode = is_evaluable(prog, self) except Exception as e: self.log_isevaluable_exception(e, prog, unkSortMap) continue if is_ok: self.evaluated_programs_str.append( c_program_str_representation) self.evaluated_programs_type_info.append(str(prog)) self.prog_unkinfo_tuples.append((prog, unkSortMap)) m += 1 else: if ecode != 2: self.log_rejected_program(prog, ecode) print('END_PROGRAM_GENERATION, Time: %s' % getElapsedTime()) pEnd = time.time() print("TIME_TAKEN_SYNTH, %s" % formatTime(pEnd - pStart))
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 testProgGenerator2(): lib = getCountFiveLib() pg = ProgramGenerator(lib) sort = getCountFiveSort() for i in range(1000): prog = pg.genProg(sort) if prog is not None: print(repr_py(prog))
def _impl(self, sort): print('begin genProg') # print(sort) print(repr_py_sort(sort)) program = method(self, sort) if program is not None: # print(program) print(repr_py(program)) else: print('None') print('end genProg') return program
def testSymbolicSynthesizerEA(): lib = getCountFiveLib() sort = getCountFiveSort() synth = SymbolicSynthesizerEA(lib, sort) scores = None for gen in range(2): progs = synth.genProgs(scores) print('Generation %d ############' % gen) for prog, _ in progs: # print(prog) print(repr_py(prog)) scores = [random.uniform(0, 1.0) for _ in progs]
def print_progs(fn_sort, libSynth, targetSize): synth = SymbolicSynthesizer(libSynth, fn_sort) cnt = 0 for prog, unkMap in synth.genProgs(): sz = ASTUtils.getSize2(prog) if sz > targetSize: break cnt += 1 print(cnt, sz, repr_py(prog)) # print(cnt, sz, prog) print(cnt)
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_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 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 synthesizeCountDigitProgram(): lib = mkDefaultLib() inType = mkRealTensorSort([1, 1, 28, 28]) outType = mkBoolTensorSort([1, 1]) recogDigitType = mkFuncSort(inType, outType) lib.addItem(PPLibItem('recogFive', recogDigitType, None)) inType = mkListSort(mkRealTensorSort([1, 1, 28, 28])) outType = mkRealTensorSort([1, 1]) countDigitType = mkFuncSort(inType, outType) synth = SymbolicSynthesizer(lib, countDigitType, nnprefix='x') for i, (prog, unks) in enumerate(synth.genProgs()): pstr = repr_py(prog) if 'fold' in pstr: if 'recogFive' in pstr: if 'zero' in pstr: print(i, pstr) print(i, prog) print(i, unks)
def mk_row(p, s_test, s_val): return mk_tag( 'tr', mk_tag('td', "%.4f / %.4f" % (s_test, s_val)) + mk_tag('td', repr_py(p)))
def logEvaluatedProgram(prog): print("Program evaluated: %s" % repr_py(prog))
def log_evaluated_program(self, prog): print("Program evaluated: %s" % repr_py(prog))
def log_rejected_program(self, prog, ecode): print("Program rejected (ecode %d): %s" % (ecode, repr_py(prog)))
def log_unhandled_program(self, prog): print("Program not handled: %s" % repr_py(prog))
def logRejectedProgram(prog, ecode): print("Program rejected (ecode %d): %s" % (ecode, repr_py(prog))) print("Program rejected (pyrep): %s" % str(prog))
def run(self) -> TaskResult: tStart = time.time() print("BEGIN_TASK, Time: %s" % getElapsedTime()) nsynth = self._mkNSynth() print("Num of programs selected for evaluation: %d" % len(nsynth.prog_unkinfo_tuples)) print("Programs selected for evaluation:") for c_prog, c_unkSortMap in nsynth.prog_unkinfo_tuples: print(repr_py(c_prog)) print(c_unkSortMap) train_io, val_io, test_io = self.get_io_examples() max_iterations = \ (self.settings.train_size // nsynth.interpreter.batch_size + ( 1 if self.settings.train_size % nsynth.interpreter.batch_size != 0 else 0)) * self.settings.epochs res = TaskResult() for i, (c_tr_io_examples, c_tr_num_items) in enumerate( iterate_diff_training_sizes( train_io, self.settings.training_percentages)): interpreter = nsynth.interpreter c_iterations_per_epoch = c_tr_num_items // interpreter.batch_size + ( 1 if c_tr_num_items % interpreter.batch_size != 0 else 0) c_num_epochs = max_iterations // c_iterations_per_epoch + ( 1 if max_iterations % c_iterations_per_epoch != 0 else 0) # interpreter.epochs = c_num_epochs rStart = time.time() print("BEGIN_RUN %d, Time: %s" % (i, getElapsedTime())) c_res = TaskResultSingle() try: nsynth_res: NeuralSynthesizerResult = nsynth.solve( c_tr_io_examples, val_io, test_io) c_res.top_k_solutions_results = nsynth_res.top_k_solutions_results c_res.num_programs = len(nsynth.prog_unkinfo_tuples) c_res.time = None # TODO: implement if isinstance(nsynth_res, NeuralSynthesizerEAResult): c_res.num_programs = nsynth_res.numProgsEvaluated c_res.progScores = [[ (repr_py(p), s) for p, s in gProgScores ] for gProgScores in nsynth_res.progScores] dir_path = self.seq.get_seq_dir() if not os.path.exists(dir_path): os.makedirs(dir_path) # top_result_evaluations_np = c_res.top_k_solutions_results[0][1]["evaluations_np"] # np.save("{}/__{}_{}.npy".format(self.seq.get_seq_dir(), nsynth.synthesizer.nnprefix, c_tr_num_items), top_result_evaluations_np) except Exception as e: print("Exception in NeuralSynthesizer.solve: %s" % str(e)) print("# Task Name: %s" % self.name()) for a in e.args: if isinstance(a, NSDebugInfo): print(a.dprog) raise res.results.append(c_res) print("END_RUN %d, Time: %s" % (i, getElapsedTime())) rEnd = time.time() print("TIME_TAKEN_RUN, %s" % formatTime(rEnd - rStart)) print("END_TASK, Time: %s" % getElapsedTime()) tEnd = time.time() print("TIME_TAKEN_TASK, %s" % formatTime(tEnd - tStart)) if hasattr(nsynth, "target_program_position"): print("Program found at place : {}".format( nsynth.target_program_position)) return res
def logUnhandledProgram(prog): print("Program not handled: %s" % repr_py(prog))
def impl(self, scores): print('GENPROGS START: scores: ', str(scores)) progUnks = _genProgs(self, scores) print('GENPROGS END: progs: ', ['None' if p is None else repr_py(p) for (p, unks) in progUnks]) # print('progs: ', progUnks) return progUnks