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