def test_validate_arg_3(self): i = {'instruction': "moo", 'symbol': 2} try: utils.validate_arg(i, 'red', utils.validate_symbol) except VentureException as e: self.assertEqual(e.exception, 'missing_argument') self.assertEqual(e.data['argument'], 'red')
def _do_labeled_predict(self, instruction): exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, modifier=_modify_expression, wrap_exception=False) label = utils.validate_arg(instruction, 'label', utils.validate_symbol) did, val = self.engine.labeled_predict(label, exp) return {'directive_id': did, 'value': val}
def _do_define(self, instruction): exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, modifier=_modify_expression, wrap_exception=False) sym = utils.validate_arg(instruction, 'symbol', utils.validate_symbol) (did, val) = self.engine.define(sym, exp) return {"directive_id": did, "value": val}
def _do_observe(self, instruction): exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, modifier=_modify_expression, wrap_exception=False) val = utils.validate_arg(instruction, 'value', utils.validate_value, modifier=_modify_value) did, weights = self.engine.observe(exp, val) return {"directive_id": did, "value": weights}
def _do_labeled_observe(self, instruction): exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, modifier=_modify_expression, wrap_exception=False) val = utils.validate_arg(instruction, 'value', utils.validate_value, modifier=_modify_value) label = utils.validate_arg(instruction, 'label', utils.validate_symbol) did, weights = self.engine.labeled_observe(label, exp, val) return {'directive_id': did, 'value': weights}
def test_validate_arg_5(self): i = {'instruction': "moo", 'symbol': "moo"} self.assertEqual( utils.validate_arg(i, 'symbol', utils.validate_symbol, modifier=lambda x: 'red'), 'red')
def _do_start_continuous_inference(self, instruction): e = utils.validate_arg(instruction, 'expression', utils.validate_expression, modifier=_modify_expression, wrap_exception=False) self.engine.start_continuous_inference(e)
def _do_predict_all(self, instruction): exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, modifier=_modify_expression, wrap_exception=False) did, val = self.engine.predict_all(exp) return {"directive_id": did, "value": val}
def _do_infer(self, instruction): e = utils.validate_arg(instruction, 'expression', utils.validate_expression, modifier=_modify_expression, wrap_exception=False) (did, val) = self.engine.infer(e) return {"directive_id": did, "value": val}
def _do_force(self, instruction): exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, wrap_exception=False) val = utils.validate_arg(instruction, 'value', utils.validate_value) inst1 = { 'instruction': 'observe', 'expression': exp, 'value': val, } o1 = self._call_core_sivm_instruction(inst1) inst2 = { 'instruction': 'infer', 'expression': [v.symbol('incorporate')] } self._call_core_sivm_instruction(inst2) inst3 = { 'instruction': 'forget', 'directive_id': o1['directive_id'], } self._call_core_sivm_instruction(inst3) return {"value": o1["value"]}
def _do_sample_all(self, instruction): exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, wrap_exception=False) inst1 = { 'instruction': 'predict_all', 'expression': exp, } o1 = self._call_core_sivm_instruction(inst1) inst2 = { 'instruction': 'forget', 'directive_id': o1['directive_id'], } self._call_core_sivm_instruction(inst2) return {'value': o1['value']}
def _register_executed_instruction(self, instruction, predicted_did, forgotten_did, response): if response is not None and 'directive_id' in response: if response['directive_id'] != predicted_did: warning = "Warning: Instruction %s was pre-assigned did %s but actually assigned did %s" print warning % (instruction, predicted_did, response['directive_id']) elif predicted_did is not None: warning = "Warning: Instruction %s was pre-assigned did %s but not actually assigned any did" print warning % (instruction, predicted_did) instruction_type = instruction['instruction'] # clear the dicts on the "clear" command if instruction_type == 'clear': self._clear() # forget directive mappings on the "forget" command if forgotten_did is not None: if forgotten_did in self.syntax_dict: del self.syntax_dict[forgotten_did] else: # XXX Presume that this is a fork-model directive id # collision as reported in Issue #586. pass if instruction_type in ['evaluate', 'infer']: # "evaluate" and "infer" are forgotten by the Engine; # forget them here, too. exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, wrap_exception=False) if instruction_type is 'infer' and self.core_sivm.engine.is_infer_loop_program( exp): # We didn't save the infer loop thing pass else: # There is at least one way in which the predicted_did # may fail to be present in these dicts: if the # instruction being executed caused a "load" operation # (which mutates the current sivm!?). if predicted_did in self.syntax_dict: del self.syntax_dict[predicted_did]
def _do_labeled_forget(self, instruction): label = utils.validate_arg(instruction, 'label', utils.validate_symbol) weights = self.engine.labeled_forget(label) return {'value': weights}
def test_validate_arg_1(self): i = {'instruction': "moo", 'symbol': "moo"} self.assertEqual( utils.validate_arg(i, 'symbol', utils.validate_symbol), "moo")
def _do_labeled_report(self, instruction): label = utils.validate_arg(instruction, 'label', utils.validate_symbol) value = self.engine.labeled_report_value(label) return {'value': value}
def _do_report(self, instruction): did = utils.validate_arg(instruction, 'directive_id', utils.validate_nonnegative_integer) return {"value": self.engine.report_value(did)}
def _do_labeled_freeze(self, instruction): label = utils.validate_arg(instruction, 'label', utils.validate_symbol) self.engine.labeled_freeze(label) return {}
def test_validate_arg_4(self): i = {'instruction': "moo"} self.assertEqual( utils.validate_arg(i, 'red', utils.validate_symbol, required=False), None)
def _do_forget(self, instruction): did = utils.validate_arg(instruction, 'directive_id', utils.validate_nonnegative_integer) weights = self.engine.forget(did) return {"value": weights}
def _do_freeze(self, instruction): did = utils.validate_arg(instruction, 'directive_id', utils.validate_nonnegative_integer) self.engine.freeze(did) return {}
def _call_core_sivm_instruction(self, instruction): desugared_instruction = copy.copy(instruction) instruction_type = instruction['instruction'] predicted_did = None # desugar the expression if instruction_type in [ 'assume', 'define', 'evaluate', 'infer', 'labeled_assume', 'labeled_observe', 'labeled_predict', 'observe', 'predict', 'predict_all', ]: exp = utils.validate_arg(instruction, 'expression', utils.validate_expression, wrap_exception=False) syntax = macro_system.expand(exp) desugared_instruction['expression'] = syntax.desugared() # for error handling predicted_did = self._record_running_instruction( instruction, (exp, syntax)) if instruction_type == 'forget': forgotten_did = instruction['directive_id'] elif instruction_type == 'labeled_forget': label = utils.validate_arg(instruction, 'label', utils.validate_symbol) forgotten_did = self.core_sivm.engine.get_directive_id(label) else: forgotten_did = None try: response = self.core_sivm.execute_instruction( desugared_instruction) except VentureException as e: if self._do_not_annotate: raise import sys info = sys.exc_info() try: e = self._annotate(e, instruction) except Exception: print "Trying to annotate an exception at SIVM level led to:" import traceback print traceback.format_exc() raise e, None, info[2] finally: if instruction_type in [ 'define', 'assume', 'observe', 'predict', 'predict_all', 'evaluate', 'infer' ]: # After annotation completes, clear the syntax # dictionary, because the instruction was # (presumably!) not recorded in the underlying # engine (so e.g. future list_directives commands # should not list it) if predicted_did in self.syntax_dict: del self.syntax_dict[predicted_did] raise e, None, info[2] self._register_executed_instruction(instruction, predicted_did, forgotten_did, response) return response