def binary_trees(): print("Binary tree example.\n--------------------\n") def height(tree): if isinstance(tree, LAtomClass): return 1 else: assert isinstance(tree, ProdClass) return max(height(tree._second._first), height( tree._second._second)) + 1 # Define the grammar. # Define some shortcuts for readability. L = LAtomSampler _ = AliasSampler # Initialize a grammar object and set the sampling rules (in this case just one single rule). tree_grammar = DecompositionGrammar({ # A binary tree is either a leaf or an inner node with two children that are binary trees. 'T': L() + L() * _('T')**2 }) # Set the builder information and initialize the grammar. # tree_grammar.set_builder(['T'], BinaryTreeBuilder()) tree_grammar.init() # Do the mathematical stuff. def get_x_for_size(n): return math.sqrt(n**2 - 1) / (2 * n) def eval_T(x): return (math.sqrt(1 - 4 * x**2) + 1) / (2 * x) def eval_T_dx(x): return (1 / (math.sqrt(1 - 4 * x**2)) + 1) / (2 * x**2) # TODO something is weird here ... target_size = 2 # x = get_x_for_size(target_size) x = 0.499999999 print(x) T = eval_T(x) print(x * T**2 / (x + x * T**2)) T_dx = eval_T_dx(x) tree_oracle = EvaluationOracle({'x': x, 'T(x,y)': T, 'T_dx(x,y)': T_dx}) # Set the newly created oracle as the active oracle. BoltzmannSamplerBase.oracle = tree_oracle print("expected size of the trees: {}\n".format( tree_oracle.get_expected_l_size('T', 'x', 'y'))) print(tree_grammar.sample_iterative('T', 'x', 'y')) print("needed oracle entries for sampling: {}\n".format( tree_grammar._collect_oracle_queries('T', 'x', 'y'))) num_samples = 10 while True: try: trees = [ tree_grammar.sample('T', 'x', 'y') for _ in range(num_samples) ] break except RecursionError: # print("Recursion error") pass avg_size = sum([tree.l_size for tree in trees]) / num_samples print("average size in {} trials: {}".format(num_samples, avg_size)) avg_height = sum([height(tree) for tree in trees]) / num_samples print("average height of trees: {}".format(avg_height)) print(2 * math.sqrt(math.pi * avg_size / 2))
BoltzmannSamplerBase.oracle = oracle BoltzmannSamplerBase.debug_mode = False grammar = dummy_sampling_grammar() grammar.init() # grammar.dummy_sampling_mode() # symbolic_x = 'x' symbolic_y = 'y' symbolic_x = 'x*G_1_dx(x,y)' # symbolic_y = 'D(x*G_1_dx(x,y),y)' sampled_class = 'D_dx_dx' grammar._precompute_evals(sampled_class, symbolic_x, symbolic_y) try: print("expected: {}\n".format( oracle.get_expected_l_size(sampled_class, symbolic_x, symbolic_y))) except PyBoltzmannError: pass # random.seed(0) # boltzmann_framework_random_gen.seed(0) l_sizes = [] i = 0 samples = 100 start = timer() while i < samples: dummy = grammar.sample_iterative(sampled_class, symbolic_x, symbolic_y) l_sizes.append(dummy.l_size) i += 1 end = timer()
def test_sampled_sizes(): all_evaluations = [reference_evals] for evaluations in all_evaluations: oracle = EvaluationOracle(evaluations) BoltzmannSamplerBase.oracle = oracle # grammar = three_connected_graph_grammar() grammar = dummy_sampling_grammar() grammar.init() grammar.dummy_sampling_mode() grammar._precompute_evals('K', 'x*G_1_dx(x,y)', 'D(x*G_1_dx(x,y),y)') classes_known_dx = [ 'G_3_arrow', #'K_dx', #'K_dy', #'J_a', #'D', #'D_dx', #'S', #'S_dx', #'P', #'P_dx', #'H', #'H_dx', #'G_2_dx', #'G_2_dx_dx', #'G_1_dx_dx', #'G_1', #'G_1_dx', #'G', #'G_dx', #'G_dx_dx' ] symbolic_x = [ 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x*G_1_dx(x,y)', 'x', 'x', 'x', 'x', 'x', 'x' ] symbolic_y = [ 'D(x*G_1_dx(x,y),y)', 'D(x*G_1_dx(x,y),y)', 'D(x*G_1_dx(x,y),y)', 'D(x*G_1_dx(x,y),y)', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' ] for index, label in enumerate(classes_known_dx): x = symbolic_x[index] y = symbolic_y[index] expected_size = oracle.get_expected_l_size(label, symbolic_x[index], symbolic_y[index]) num_samples = 10000 count = 0 sizes = [] rec_errors = 0 while count < num_samples: try: sizes.append(grammar.sample(label, x, y).l_size) count += 1 except RecursionError: rec_errors += 1 observed = sum(sizes) / len(sizes) print( "class: {} \t expected: {} \t observed: {} \t rec. errors: {} \t difference: {}" .format(label, expected_size, observed, rec_errors, observed / expected_size - 1)) print()