def main(): logger.info('Parsing Spec...') spec = S.parse_file('example/simplestring.tyrell') logger.info('Parsing succeeded') logger.info('Building synthesizer...') synthesizer = Synthesizer( # enumerator=SmtEnumerator(spec, depth=3, loc=1), # plus(@param1, @param0) / plus(@param0, @param1) enumerator=SmtEnumerator( spec, depth=4, loc=3), # plus(plus(@param0, const(_apple_)), @param1) decider=ExampleConstraintDecider( spec=spec, interpreter=ToyInterpreter(), examples=[ # Example(input=["a", "b"], output="ab"), # plus(@param0, @param1) # Example(input=["b", "a"], output="ab"), # plus(@param1, @param0) Example(input=["a", "b"], output="a_apple_b"), ], )) logger.info('Synthesizing programs...') prog = synthesizer.synthesize() if prog is not None: logger.info('Solution found: {}'.format(prog)) else: logger.info('Solution not found!')
def main(): logger.info('Parsing Spec...') spec = S.parse_file('example/toy.tyrell') logger.info('Parsing succeeded') logger.info('Building synthesizer...') synthesizer = Synthesizer( enumerator=SmtEnumerator(spec, depth=3, loc=2), decider=ExampleConstraintDecider( spec=spec, interpreter=ToyInterpreter(), examples=[ # we want to synthesize the program (x-y)*y (depth=3, loc=2) # which is also equivalent to x*y-y*y (depth=3, loc=3) Example(input=[4, 3], output=3), Example(input=[6, 3], output=9), Example(input=[1, 2], output=-2), Example(input=[1, 1], output=0), ])) logger.info('Synthesizing programs...') prog = synthesizer.synthesize() if prog is not None: logger.info('Solution found: {}'.format(prog)) else: logger.info('Solution not found!')
def cli(spec_file, verbosity): ''' Parse the given Tyrell DSL spec file ''' logger.setLevel(verbosity) try: tyrell_spec = S.parse_file(spec_file) print_spec(tyrell_spec) except (S.ParseError, S.ParseTreeProcessingError) as e: logger.error('Spec parsing error: {}'.format(e))
def main(): global number parser = argparse.ArgumentParser() parser.add_argument('-i0', '--input0', type=str) parser.add_argument('-o', '--output', type=str) parser.add_argument('-l', '--length', type=int) parser.add_argument('-d', '--depth', type=int) parser.add_argument('-t', '--tyrellpath', type=str) parser.add_argument('-m', '--plotmax', type=float) args = parser.parse_args() loc_val = args.length depth = args.depth # Input and Output must be in CSV format. input0 = args.input0 output = args.output # This is required by Ruben. init_input_tbl('input0', input0) init_tbl('output', output) build_tab('output').max_input = args.plotmax logger.info('Parsing Spec...') spec = S.parse_file(args.tyrellpath) logger.info('Parsing succeeded') logger.info('Building synthesizer...') r_interpreter = RInterpreter() synthesizer = Synthesizer( #loc: # of function productions # enumerator=SmtEnumerator(spec, depth=2, loc=1), # enumerator=SmtEnumerator(spec, depth=3, loc=2), enumerator=SmtEnumerator(spec, depth=depth, loc=loc_val, evaluator=Evaluator(r_interpreter)), decider=SmtBasicDecider( spec=spec, interpreter=r_interpreter, examples=[ # Example(input=[DataFrame2(benchmark1_input)], output=benchmark1_output), Example(input=['input0'], output='output'), ], equal_output=eq_r ) ) logger.info('Synthesizing programs...') synthesizer.set_table(Table) prog = synthesizer.synthesize() logger.info('Number of candidates: {}'.format(number)) if prog is not None: logger.info('Selected solution: {}'.format(prog)) else: logger.info('Solution not found!') sys.stderr.flush()
def main(): ##### Input-output constraint benchmark1_input = robjects.r(''' dat <- read.table(text=" round var1 var2 nam val round1 22 33 foo 0.16912201 round2 11 44 foo 0.18570826 round1 22 33 bar 0.12410581 round2 11 44 bar 0.03258235 ", header=T) dat ''') benchmark1_output = robjects.r(''' dat2 <- read.table(text=" nam val_round1 val_round2 var1_round1 var1_round2 var2_round1 var2_round2 bar 0.1241058 0.03258235 22 11 33 44 foo 0.1691220 0.18570826 22 11 33 44 ", header=T) dat2 ''') logger.info('Parsing Spec...') spec = S.parse_file('example/morpheus.tyrell') logger.info('Parsing succeeded') logger.info('Building synthesizer...') synthesizer = Synthesizer( #loc: # of function productions # enumerator=SmtEnumerator(spec, depth=2, loc=1), # enumerator=SmtEnumerator(spec, depth=3, loc=2), enumerator=SmtEnumerator(spec, depth=4, loc=3), decider=ExampleConstraintDecider( spec=spec, interpreter=MorpheusInterpreter(), examples=[ # Example(input=[DataFrame2(benchmark1_input)], output=benchmark1_output), Example(input=['dat'], output='dat2'), ], equal_output=eq_r ) ) logger.info('Synthesizing programs...') prog = synthesizer.synthesize() if prog is not None: logger.info('Solution found: {}'.format(prog)) else: logger.info('Solution not found!')
def main(seed): global conn conn = create_connection("squares.db") # c = conn.cursor() # benchmark1_input = "" # c.execute("select * from faculty;") # rows = c.fetchall() # for r in rows: # # print(str(r)) # benchmark1_input += str(r) # print(benchmark1_input) benchmark1_output = "" c = conn.cursor() c.execute("SELECT fid, fname FROM faculty natural join class;") rows = c.fetchall() for r in rows: benchmark1_output += str(r) # print(r) # print(benchmark1_output) logger.info('Parsing Spec...') spec = S.parse_file('example/squares.tyrell') logger.info('Parsing succeeded') logger.info('Building synthesizer...') synthesizer = Synthesizer( #loc: # of function productions # enumerator=SmtEnumerator(spec, depth=2, loc=1), # enumerator=SmtEnumerator(spec, depth=3, loc=2), enumerator=SmtEnumerator(spec, depth=4, loc=3), # enumerator=RandomEnumerator( # spec, max_depth=4, seed=seed), decider=ExampleConstraintDecider( spec=spec, interpreter=SquaresInterpreter(), examples=[ Example(input=None, output=benchmark1_output), ], equal_output=eq_r ) ) logger.info('Synthesizing programs...') prog = synthesizer.synthesize() if prog is not None: logger.info('Solution found: {}'.format(prog)) else: logger.info('Solution not found!') conn.close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-i0', '--input0', type=str) parser.add_argument('-i1', '--input1', type=str) parser.add_argument('-o', '--output', type=str) parser.add_argument('-l', '--length', type=int) args = parser.parse_args() loc_val = args.length # Input and Output must be in CSV format. input0 = args.input0 input1 = args.input1 output = args.output # This is required by Ruben. depth_val = loc_val + 1 print(input0, input1, output, loc_val) init_tbl('input0', input0) #FIXME: ignore the second input table for now. init_tbl('output', output) logger.info('Parsing Spec...') spec = S.parse_file('example/morpheus.tyrell') logger.info('Parsing succeeded') # Reading the n-gram model. sketches = [line.strip() for line in open("./ngram.txt", 'r')] logger.info('Building synthesizer...') synthesizer = Synthesizer( #loc: # of function productions enumerator=BidirectEnumerator(spec, depth=depth_val, loc=loc_val, sk_queue=sketches), decider=ExampleConstraintPruningDecider( spec=spec, interpreter=MorpheusInterpreter(), examples=[ # Example(input=[DataFrame2(benchmark1_input)], output=benchmark1_output), Example(input=['input0'], output='output'), ], equal_output=eq_r)) logger.info('Synthesizing programs...') prog = synthesizer.synthesize() if prog is not None: logger.info('Solution found: {}'.format(prog)) else: logger.info('Solution not found!')
def main(): logger.info('Parsing Spec...') spec = S.parse_file('example/deepcoder.tyrell') logger.info('Parsing succeeded') logger.info('Building synthesizer...') synthesizer = Synthesizer( enumerator=SmtEnumerator(spec, depth=5, loc=5), decider=ExampleConstraintDecider( spec=spec, interpreter=DeepCoderInterpreter(), examples=[ Example(input=[[6, 2, 4, 7, 9], [5, 3, 6, 1, 0]], output=27), ], # equal_output=eq_deepcoder )) logger.info('Synthesizing programs...') prog = synthesizer.synthesize() if prog is not None: logger.info('Solution found: {}'.format(prog)) else: logger.info('Solution not found!')
enumerator = SmtEnumerator(spec, depth=depth, loc=loc) decider = ExampleConstraintDecider(spec=spec, interpreter=Interpreter(), examples=make_examples(examples)) return enumerator, decider def exhaustive(spec, max_depth, examples): enumerator = ExhaustiveEnumerator(spec, max_depth) decider = ExampleDecider(Interpreter(), make_examples(examples)) return enumerator, decider spec = parse_file('example/outsystems.tyrell') examples = [ (["John", "Doe"], 'doejohn'), # (["John ", " Doe"], 'doejohn'), # ([" John ", " Doe "], 'doejohn'), # (["Jane", "Smith"], 'smithjane'), # (["Jane ", " Smith"], 'smithjane'), # ([" Jane ", " Smith "], 'smithjane'), ] def smt_main(spec): # for loc in range(1, 6): # bug synthesize(*smt(spec, depth=6, loc=4, examples=examples))
def synthesize(inputs, output, oracle_output, prune, extra_consts): global full_table full_table = oracle_output logger.setLevel('INFO') """ synthesizer table transformation programs from input-output examples Args: inputs: a list of input tables (represented as a list of named tuples) output: a symbolic table (of class symbolic.SymTable) full_output: the oracle output table, the task would need to generalize to it extra_consts: extra constants provided to the solver Returns: a list of transformation programs s.t. p(inputs) = output """ #print("output table:\n", output) #print("input table:\n", inputs[0]) loc_val = 2 output_data = json.dumps(output.instantiate()) full_data = json.dumps(oracle_output.instantiate()) input_data = json.dumps(inputs[0], default=default) init_tbl_json_str('input0', input_data) init_tbl_json_str('output', output_data) # if prune == 'morpheus': # init_tbl_json_str('output', full_data) # else: # init_tbl_json_str('output', output_data) print(robjects.r('input0')) print(robjects.r('output')) depth_val = loc_val + 1 logger.info('Parsing spec ...') # provide additional string constants to the solver grammar_base = "dsl/tidyverse.tyrell.base" grammar_file = "dsl/__tidyverse__.tyrell" synth_utils.update_search_grammar(extra_consts, grammar_base, grammar_file) spec = S.parse_file(grammar_file) logger.info('Parsing succeeded') logger.info('Building synthesizer ...') global iter_num iter_num = 0 for loc in range(1, loc_val + 1): eq_fun = subset_eq if prune == 'none': eq_fun = proj_eq enumerator = BidirectEnumerator(spec, depth=loc + 1, loc=loc) decider = BidirectionalDecider(spec=spec, interpreter=MorpheusInterpreter(), examples=[ Example(input=['input0'], output='output'), ], prune=prune, equal_output=eq_fun) if prune == 'morpheus': enumerator = SmtEnumerator(spec, depth=loc + 1, loc=loc) decider = ExampleConstraintPruningDecider( spec=spec, interpreter=MorpheusInterpreter(), examples=[ # Example(input=[DataFrame2(benchmark1_input)], output=benchmark1_output), Example(input=['input0'], output='output'), ], equal_output=eq_fun) synthesizer = Synthesizer(enumerator=enumerator, decider=decider) logger.info('Synthesizing programs ...') prog = synthesizer.synthesize() if prog is not None: logger.info('Solution found: {}'.format(prog)) return [prog] else: logger.info('Solution not found!') return []