コード例 #1
0
def sample_datum(g=basegrammar, N=5, V=100, L=10, compute_sketches=False, top_k_sketches=100, inv_temp=1.0, reward_fn=None, sample_fn=None, dc_model=None, use_timeout=False):

	#sample a program:
	#with timing("sample program"):
	program = sample_program(g, max_len=L, max_string_size=V)  # TODO
	# if program is bad: return None  # TODO

	# find IO
	#with timing("sample IO:"):
	IO = generate_IO_examples(program, num_examples=N,  max_string_size=V)  # TODO
	if IO is None: return None
	IO = tuple(IO)
	# find tp
	tp = tprogram
	# TODO

	# find pseq
	pseq = tuple(flatten_program(program)) #TODO

	if compute_sketches:
		# find sketch
		grammar = g if not dc_model else dc_model.infer_grammar(IO)
		#with timing("make_holey"):
		sketch, reward, sketchprob = make_holey_deepcoder(program, top_k_sketches, grammar, tp, inv_temp=inv_temp, reward_fn=reward_fn, sample_fn=sample_fn, use_timeout=use_timeout) #TODO

		# find sketchseq
		sketchseq = tuple(flatten_program(sketch))
	else:
		sketch, sketchseq, reward, sketchprob = None, None, None, None

	return Datum(tp, program, pseq, IO, sketch, sketchseq, reward, sketchprob)
コード例 #2
0
def sample_program(g=basegrammar, max_len=10, max_string_size=100):
    request = tprogram
    #with timing("sample from grammar"):
    p = g.sample(request, maximumDepth=5, maxAttempts=None)  #todo args??

    if flatten_program(p).count('concat_list') >= max_len:
        #resample
        return sample_program(g=g,
                              max_len=max_len,
                              max_string_size=max_string_size)  # TODO
    else:
        return p
コード例 #3
0
    #normalize_weights
    w_sum = sum(w for w in weights)
    weights = [w / w_sum for w in weights]

    prog_reward_probs = list(zip(progs, rewards, weights))

    if k > 1:
        x = random.choices(prog_reward_probs, weights=weights, k=1)
        return x[0]  #outputs prog, prob
    else:
        return prog_reward_probs[0]  #outputs prog, prob


if __name__ == '__main__':
    g = Grammar.fromProductions(RobustFillProductions())
    print(len(g))
    request = tprogram
    p = g.sample(request)
    print("request:", request)
    print("program:")
    print(prettyProgram(p))
    s = 'abcdefg'
    e = p.evaluate([])
    print("prog applied to", s)
    print(e(s))
    print("flattened_program:")
    flat = flatten_program(p)
    print(flat)
    pr = parseprogram(flat, request)
    print(prettyProgram(pr))
コード例 #4
0
def sample_datum(basegrammar,
                 N=5,
                 V=100,
                 L=10,
                 compute_sketches=False,
                 top_k_sketches=100,
                 inv_temp=1.0,
                 reward_fn=None,
                 sample_fn=None,
                 dc_model=None,
                 use_timeout=False,
                 improved_dc_model=False,
                 nHoles=1,
                 input_noise=False):

    #sample a program:
    #with timing("sample program"):
    program = sample_program(g=basegrammar, max_len=L,
                             max_string_size=V)  # TODO
    # if program is bad: return None  # TODO

    # find IO
    #with timing("sample IO:"):
    IO = generate_IO_examples(program, num_examples=N,
                              max_string_size=V)  # TODO
    if IO is None: return None

    if input_noise:
        import random
        import string
        replace_with = random.choice(string.printable[:-4])
        ex = random.choice(range(len(IO)))
        i_or_o = random.choice(range(2))

        old = IO[ex][i_or_o]

        IO[ex] = list(IO[ex])

        ln = len(old)
        if ln >= 1:
            idx = random.choice(range(ln))

            mut = random.choice(range(3))

            if type(IO[ex]) == tuple:
                IO[ex] = list(IO[ex])

            if mut == 0:  #removal
                IO[ex][i_or_o] = old[:idx] + old[idx + 1:]
            elif mut == 1:  #sub
                IO[ex][i_or_o] = old[:idx] + replace_with + old[idx + 1:]
            else:  #insertion
                IO[ex][i_or_o] = old[:idx] + replace_with + old[idx:]

        IO[ex] = tuple(IO[ex])

    IO = tuple(IO)
    # find tp
    tp = tprogram
    # TODO

    # find pseq
    pseq = tuple(flatten_program(program))  #TODO

    if compute_sketches:
        # find sketch
        #grammar = g if not dc_model else dc_model.infer_grammar(IO)
        #with timing("make_holey"):
        # sketch, reward, sketchprob = make_holey_deepcoder(program,
        # 													top_k_sketches,
        # 													grammar,
        # 													tp,
        # 													inv_temp=inv_temp,
        # 													reward_fn=reward_fn,
        # 													sample_fn=sample_fn,
        # 													use_timeout=use_timeout) #TODO

        sketch, reward, sketchprob = make_holey_algolisp(
            program,
            top_k_sketches,
            tp,
            basegrammar,
            dcModel=dc_model,
            improved_dc_model=improved_dc_model,
            return_obj=Hole,
            dc_input=IO,
            inv_temp=inv_temp,
            reward_fn=reward_fn,
            sample_fn=sample_fn,
            use_timeout=use_timeout,
            nHoles=nHoles,
            domain='text')

        # find sketchseq
        sketchseq = tuple(flatten_program(sketch))
    else:
        sketch, sketchseq, reward, sketchprob = None, None, None, None

    return Datum(tp, program, pseq, IO, sketch, sketchseq, reward, sketchprob)