def init_modules(train_split=False): """Inits the dicts containing functions for generating modules.""" if filtered_modules: return # already initialized all_modules = collections.OrderedDict([]) if train_split: all_modules['train-easy'] = modules.train(_make_entropy_fn(0, 3)) all_modules['train-medium'] = modules.train(_make_entropy_fn(1, 3)) all_modules['train-hard'] = modules.train(_make_entropy_fn(2, 3)) else: all_modules['train'] = modules.train(_make_entropy_fn(0, 1)) all_modules['interpolate'] = modules.test() all_modules['extrapolate'] = modules.test_extra() counts['train'] = FLAGS.per_train_module counts['train-easy'] = FLAGS.per_train_module // 3 counts['train-medium'] = FLAGS.per_train_module // 3 counts['train-hard'] = FLAGS.per_train_module // 3 counts['interpolate'] = FLAGS.per_test_module counts['extrapolate'] = FLAGS.per_test_module for regime_, modules_ in six.iteritems(all_modules): filtered_modules[regime_] = _filter_and_flatten(modules_)
def generate_problems(filter, difficulty, num_examples): """Generate question-answer pairs using the DeepMind Mathematics Dataset. Keyword arguments: filter -- only use modules that contain this keyword difficulty -- float between 0.0 and 1.0 corresponding to the entropy used in generating constants\ for each problem type num_examples -- number of problems to generate for each module """ problems = collections.defaultdict(lambda: []) initial_modules = modules.train(util._make_entropy_fn(difficulty, 1)) filtered_modules = util._filter_and_flatten(filter, initial_modules) for module_name, module in six.iteritems(filtered_modules): # These magic print constants make the header bold. if FLAGS.print_results: print("\033[1m{}\033[0m".format(module_name)) num_dropped = 0 for _ in range(num_examples): problem, extra_dropped = util.sample_from_module(module) num_dropped += extra_dropped if FLAGS.print_results: print(f"Module name: {module_name}") problems[module_name].append(problem) if num_dropped > 0: if FLAGS.print_results: logging.warning("Dropped %d examples", num_dropped) return problems
def __init__(self, categories=["algebra__linear_1d", "probability"], difficulty=0.5, num_iterations=12, batch_size=4): problems = collections.defaultdict(lambda: []) initial_modules = modules.train(_make_entropy_fn(difficulty, 1)) filtered_modules = _filter_and_flatten(categories, initial_modules) self.sampled_modules = list(six.iteritems(filtered_modules)) self.num_iterations = int(num_iterations * batch_size)
def __getitem__(self, idx): difficulty = self.current_iteration / self.total_iterations initial_modules = modules.train(_make_entropy_fn(difficulty, 1)) filtered_modules = _filter_and_flatten(self.categories, initial_modules) self.sampled_modules = list(six.iteritems(filtered_modules)) problem = sample_from_module(self.sampled_modules[np.random.randint( 0, len(self.sampled_modules), (1))[0]][1], show_dropped=False)[0] # converts to tokens and adds BOS and EOS tokens ques, anws = np_encode_string(str(problem[0])), np_encode_string( str(problem[1])) self.current_iteration += 1 return ques, anws
def __init__(self, categories, mean_accuracy_by_category, model, difficulty=0.5, num_iterations=12, batch_size=4, starting_eps=0, eps_grad=0): self.categories = categories self.model = model self.total_iterations = int(num_iterations * batch_size) self.current_iteration = 0 self.starting_eps = starting_eps self.eps_grad = eps_grad assert (len(self.categories) == len(mean_accuracy_by_category)) self.category_probabilities = self.model.forward( mean_accuracy_by_category) initial_modules = modules.train(_make_entropy_fn(difficulty, 1)) filtered_modules = _filter_and_flatten(categories, initial_modules) self.sampled_modules = list(six.iteritems(filtered_modules)) assert (torch.sum(self.category_probabilities) == 1)
def _sampling_func_from_module(mname, entropy_args): pname = mname.split('__') func = modules.train( generate._make_entropy_fn(*entropy_args))[pname[0]][pname[1]] return func