def test_generate_expression_sess_none(self, mock_next_production_rules,
partial_sequence, expected_result):
with mock.patch.object(partial_sequence_model_generator,
'generate_next_production_rule_randomly',
side_effect=mock_next_production_rules):
self.assertDictEqual(
partial_sequence_model_generator.generate_expression(
sess=None,
grammar=self.grammar,
max_length=5,
partial_sequence=partial_sequence), expected_result)
def before_run(self, run_context):
"""Generates expressions condition on symbolic properties.
Args:
run_context: tf.train.SessionRunContext.
Returns:
tf.train.SessionRunArgs used to update the pending call to session.run().
"""
if self._finished_generation:
feed_match_ratio = []
feed_fail_ratio = []
else:
total_count = 0
# Count the number of expressions generated with leading powers match the
# conditions.
match_count = 0
# Count the number of sympy fail. Sympy may fail for complicated
# expressions. That doesn't mean the leading powers do match the
# conditions.
# It is just when the expression hits some corner cases in sympy.
fail_count = 0
for leading_powers_abs_sum in self._generation_leading_powers_abs_sums:
for leading_at_0, leading_at_inf in get_leading_powers(
leading_powers_abs_sum):
for i in range(self._num_expressions_per_condition):
logging.info('generate sample %d / %d', i,
self._num_expressions_per_condition)
result = partial_sequence_model_generator.generate_expression(
sess=run_context.session,
grammar=self._grammar,
max_length=self._max_length,
symbolic_properties_dict={
'leading_at_0': leading_at_0,
'leading_at_inf': leading_at_inf
},
numerical_values=None,
clip_value_min=None,
clip_value_max=None,
random_state=None,
sampling=True,
input_variable_scope='features')
logging.info('generate expression %s',
result['expression_string'])
logging.info('is_terminal %s', result['is_terminal'])
total_count += 1
try:
leading_at_0_value = timeout.RunWithTimeout(
self.
_symbolic_property_functions['leading_at_0'],
args=(result['expression_string'], ),
name='leading_at_0').run(time_limit_seconds=30)
leading_at_inf_value = timeout.RunWithTimeout(
self.
_symbolic_property_functions['leading_at_inf'],
args=(result['expression_string'], ),
name='leading_at_inf').run(
time_limit_seconds=30)
except (timeout.FunctionTimeoutError, ValueError):
leading_at_0_value = np.nan
leading_at_inf_value = np.nan
fail_count += 1
if (np.isclose(leading_at_0_value, leading_at_0)
and np.isclose(leading_at_inf_value,
leading_at_inf)):
match_count += 1
if total_count == 0:
match_ratio = 0.
fail_ratio = 0.
else:
match_ratio = float(match_count) / total_count
fail_ratio = float(fail_count) / total_count
self._finished_generation = True
feed_match_ratio = [match_ratio]
feed_fail_ratio = [fail_ratio]
return tf.train.SessionRunArgs(
fetches={
'match_ratio': 'conditional_generation/match_ratio:0',
'fail_ratio': 'conditional_generation/fail_ratio:0',
},
feed_dict={
'conditional_generation/match_ratio:0': feed_match_ratio,
'conditional_generation/fail_ratio:0': feed_fail_ratio,
})