def control_av_in_atomspace(self): """Called in the main loop to update av For now we control av in this way: if new block appeared or old block disappeared: (e.g. finding such atom structures EvaluationLink PredicateNode "new_block" StructureNode "objXX" ) increase its av remove the new block/ disappeared predicate for all block: decrease their av """ new_handle = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ) ).h) new_atom = Atom(new_handle, self._atomspace) disappeared_handle = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ) ).h) disappeared_atom = Atom(disappeared_handle, self._atomspace) all_eval_links = new_atom.out + disappeared_atom.out print "Found %s new blocks." % len(new_atom.out) print "Found %s disappeared blocks." % len(disappeared_atom.out) for eval_link in all_eval_links: # TODO: This next line needs to be more specific rather than just # selecting the first link. atom = eval_link.out[1] cur_sti = atom.av['sti'] # TODO: Make the 200 a constant, this occurs one other place. self._atomspace.set_av(atom.h, sti=cur_sti + 200) self._atomspace.remove(eval_link) print len(self._atomspace.get_atoms_by_type(types.StructureNode)), " Structure Nodes in AtomSpace." for block in self._atomspace.get_atoms_by_type(types.StructureNode): cur_sti = block.av['sti'] self._atomspace.set_av( block.h, sti=max( cur_sti - 10, cur_sti / 1.36471))
def init_factor_graph_concept_node(): bind_link = BindLink( TypedVariableLink(VariableNode('$V'), TypeNode('ConceptNode')), EvaluationLink(GroundedPredicateNode('py: eval_has_dv'), ListLink(VariableNode('$V'))), ExecutionOutputLink( GroundedSchemaNode('py: init_factor_graph_concept_node_formula'), ListLink(VariableNode('$V')))) bindlink(atomspace, bind_link)
def control_av_in_atomspace(self): """Called in the main loop to update av For now we control av in this way: if new block appeared or old block disappeared: (e.g. finding such atom structures EvaluationLink PredicateNode "new_block" StructureNode "objXX" ) increase its av remove the new block/ disappeared predicate for all block: decrease their av """ new_atom = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ) )) disappeared_atom = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ) )) all_eval_links = new_atom.out + disappeared_atom.out print "Found %s new blocks." % len(new_atom.out) print "Found %s disappeared blocks." % len(disappeared_atom.out) for eval_link in all_eval_links: # TODO: This next line needs to be more specific rather than just # selecting the first link. atom = eval_link.out[1] cur_sti = atom.av['sti'] # TODO: Make the 200 a constant, this occurs one other place. self._atomspace.set_av(atom, sti=cur_sti + 200) self._atomspace.remove(eval_link) print len(self._atomspace.get_atoms_by_type(types.StructureNode)), " Structure Nodes in AtomSpace." for block in self._atomspace.get_atoms_by_type(types.StructureNode): cur_sti = block.av['sti'] self._atomspace.set_av( block, sti=max( cur_sti - 10, cur_sti / 1.36471))
def control_av_in_atomspace(self): """Called in the main loop to update av For now we control av in this way: if new block appeared or old block disappeared: (e.g. finding such atom structures EvaluationLink PredicateNode "new_block" StructureNode "objXX" ) increase its av remove the new block/ disappeared predicate for all block: decrease their av """ new_handle = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ) ).h) new_atom = Atom(new_handle, self._atomspace) disappeared_handle = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ) ).h) disappeared_atom = Atom(disappeared_handle, self._atomspace) all_eval_links = new_atom.out + disappeared_atom.out print "Found %s new blocks." % len(new_atom.out) print "Found %s disappeared blocks." % len(disappeared_atom.out) for eval_link in all_eval_links: atom = eval_link.out[1] cur_sti = atom.av['sti'] #print cur_sti self._atomspace.set_av(atom.h, sti=cur_sti + 5) #print atom self._atomspace.remove(eval_link) print len(self._atomspace.get_atoms_by_type(types.StructureNode)), " Structure Nodes in AtomSpace." for block in self._atomspace.get_atoms_by_type(types.StructureNode): cur_sti = block.av['sti'] self._atomspace.set_av(block.h, sti=cur_sti - 1)
def control_av_in_atomspace(self): """Called in the main loop to update av For now we control av in this way: if new block appeared or old block disappeared: (e.g. finding such atom structures EvaluationLink PredicateNode "new_block" StructureNode "objXX" ) increase its av remove the new block/ disappeared predicate for all block: decrease their av """ new_handle = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ), EvaluationLink( PredicateNode("new_block"), VariableNode("$x") ) ).h) new_atom = Atom(new_handle, self._atomspace) disappeared_handle = bindlink(self._atomspace, BindLink( VariableNode("$x"), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ), EvaluationLink( PredicateNode("disappeared"), VariableNode("$x") ) ).h) disappeared_atom = Atom(disappeared_handle, self._atomspace) all_eval_links = new_atom.out + disappeared_atom.out for eval_link in all_eval_links: atom = eval_link.out[1] cur_sti = atom.av['sti'] print cur_sti self._atomspace.set_av(atom.h, sti=cur_sti + 5) print atom self._atomspace.remove(eval_link) for block in self._atomspace.get_atoms_by_type(types.StructureNode): cur_sti = block.av['sti'] self._atomspace.set_av(block.h, sti=cur_sti - 1) print block
def get_members_of_old(self, geneset): """ deprecated: using python instead of pattern matcher now b/c it's faster """ # cache members of geneset if geneset not in self.set_members_dict: bindlink_query = \ ''' (BindLink (VariableNode "$member") (ImplicationLink (MemberLink (VariableNode "$member") (ConceptNode {0})) (VariableNode "$member"))) '''.format('"' + geneset.name.strip() + '"') bindlink_h = scheme_eval_h(self.atomspace, bindlink_query) results_h = bindlink(self.a, bindlink_h) genes = self.set_members_dict[geneset] \ = set(atoms_in_listlink_h(self.a, results_h)) # or, using scheme (cog-bind) method # self.set_members_dict[geneset] = set(scheme_eval_list( # self.a,'(get_members_of "' + geneset.name + '")')) else: genes = self.set_members_dict[geneset] return genes
def get_predicate(atomspace, predicate_name, target_node, num_of_val): if num_of_val == 1: var = VariableNode("$x") elif num_of_val > 1: var_nodes = [] for i in range(num_of_val): var_nodes.append(VariableNode(str(i))) var = VariableList(*var_nodes) else: return None result_set = bindlink( atomspace, BindLink( var, EvaluationLink(PredicateNode(predicate_name), ListLink(target_node, var)), var)) try: result_set_out = result_set.out[0] if result_set_out.type == types.ListLink: result_list = result_set_out.out return result_list else: return result_set_out except IndexError as e: print "get predicate err: get no result %s" % e return None
def get_predicate(atomspace, predicate_name, target_node, num_of_val): if num_of_val == 1: var = VariableNode("$x") elif num_of_val > 1: var_nodes = [] for i in range(num_of_val): var_nodes.append(VariableNode(str(i))) var = VariableList(*var_nodes) else: return None result_set = bindlink(atomspace, BindLink( var, EvaluationLink( PredicateNode(predicate_name), ListLink( target_node, var ) ), var ).h ) try: result_set_out = Atom(result_set, atomspace).out[0] if atomspace.get_type(result_set_out.h) == types.ListLink: result_list = result_set_out.out return result_list else: return result_set_out except IndexError, e: print "get predicate err: get no result %s" % e return None
def show_edges(): bind_link = BindLink( VariableList( TypedVariableLink(VariableNode('$F'), TypeNode('ConceptNode')), TypedVariableLink(VariableNode('$V'), TypeNode('ConceptNode'))), get_edge_predicate(VariableNode('$F'), VariableNode('$V')), get_edge_predicate(VariableNode('$F'), VariableNode('$V'))) print(bindlink(atomspace, bind_link))
def run_program(self, features, program): self.atomspace = pushAtomspace(self.atomspace) self._add_scene_atom(features) eval_link, left, inheritance_set = tbd_helpers.return_prog( commands=tuple(reversed(program)), atomspace=self.atomspace) bind_link = tbd_helpers.build_bind_link(self.atomspace, eval_link, inheritance_set) result = bindlink.bindlink(self.atomspace, bind_link) answer = self.argmax(result) self.atomspace = popAtomspace(self.atomspace) return answer
def init_factor_graph_implication_link(): bind_link = BindLink( VariableList( TypedVariableLink(VariableNode('$V1'), TypeNode('ConceptNode')), TypedVariableLink(VariableNode('$V2'), TypeNode('ConceptNode'))), AndLink( # Preconditions EvaluationLink( GroundedPredicateNode('py: eval_has_dv'), ListLink( ImplicationLink(VariableNode('$V1'), VariableNode('$V2')))), # Pattern clauses ImplicationLink(VariableNode('$V1'), VariableNode('$V2'))), ExecutionOutputLink( GroundedSchemaNode( 'py: init_factor_graph_implication_link_formula'), ListLink(ImplicationLink(VariableNode('$V1'), VariableNode('$V2')), VariableNode('$V1'), VariableNode('$V2')))) bindlink(atomspace, bind_link)
def send_message_factor_variable(): bind_link = BindLink( VariableList( TypedVariableLink(VariableNode('$F'), TypeNode('ConceptNode')), TypedVariableLink(VariableNode('$V'), TypeNode('ConceptNode'))), AndLink( NotLink( EvaluationLink( GroundedPredicateNode('py: eval_has_value'), ListLink( get_edge_predicate(VariableNode('$F'), VariableNode('$V')), MESSAGE_FACTOR_VARIABLE_KEY))), EvaluationLink( GroundedPredicateNode('py: can_send_message_factor_variable'), ListLink(VariableNode('$F'), VariableNode('$V'))), # Pattern clauses EvaluationLink(FACTOR_KEY, VariableNode('$F')), EvaluationLink(VARIABLE_KEY, VariableNode('$V')), get_edge_predicate(VariableNode('$F'), VariableNode('$V'))), ExecutionOutputLink( GroundedSchemaNode('py: send_message_factor_variable_formula'), ListLink(VariableNode('$F'), VariableNode('$V')))) bindlink(atomspace, bind_link)
def get_variable_domain(variable): # TBD: check also number of evidences bind_link = BindLink( VariableList(VariableNode("$type"), VariableNode("$value")), AndLink(InheritanceLink(variable, VariableNode("$type")), InheritanceLink(VariableNode("$type"), VariableNode("$value"))), VariableNode("$value")) values_link = bindlink(atomspace, bind_link) values = list(map(lambda node: node.name, values_link.out)) values.sort() return values
def test_bindlink(self): # Remember the starting atomspace size. starting_size = self.atomspace.size() # Run bindlink. atom = bindlink(self.atomspace, self.bindlink_atom) self.assertTrue(atom is not None and atom.value() > 0) # Check the ending atomspace size, it should have added one SetLink. ending_size = self.atomspace.size() self.assertEquals(ending_size, starting_size + 1) # The SetLink should have three items in it. self.assertEquals(atom.arity, 3) self.assertEquals(atom.type, types.SetLink)
def get_all_neighbors_variables(factor): """ Find all variables which are connected with the given factor. This method is used for Factor tensor message multiplication to skip position of the variable the message is sent to. :param factor: factor in factor graph :return: the SetLink which contains a list of all variables connected to the factor. """ bind_link = BindLink( VariableNode('$V'), AndLink(get_variable_predicate(VariableNode('$V')), get_edge_predicate(factor, VariableNode('$V'))), VariableNode('$V')) factors_link = bindlink(atomspace, bind_link) return factors_link
def get_neighbors_factors(variable, exclude_factor): """ Find all but exclude_factor factors which are connected with the given variable. :param variable: variable in factor graph :param exclude_factor: the factor that must must be excluded from the result. :return: the SetLink which contains a list of factors except the given factor. """ bind_link = BindLink( VariableNode('$F'), AndLink(get_factor_predicate(VariableNode('$F')), get_edge_predicate(VariableNode('$F'), variable), NotLink(EqualLink(exclude_factor, VariableNode('$F')))), VariableNode('$F')) factors_link = bindlink(atomspace, bind_link) return factors_link
def get_neighbors_variables(factor, exclude_variable): """ Find all but exclude_variable variables which are connected with the given factor. :param factor: factor in factor graph :param exclude_variable: the variable that must must be excluded from the result. :return: the SetLink which contains a list of variables except the given variable. """ bind_link = BindLink( VariableNode('$V'), AndLink(get_variable_predicate(VariableNode('$V')), get_edge_predicate(factor, VariableNode('$V')), NotLink(EqualLink(exclude_variable, VariableNode('$V')))), VariableNode('$V')) factors_link = bindlink(atomspace, bind_link) return factors_link
def test_bindlink(self): # Remember the starting atomspace size. starting_size = self.atomspace.size() # Run bindlink. result = bindlink(self.atomspace, self.bindlink_handle) self.assertTrue(result is not None and result.value() > 0) # Check the ending atomspace size, it should have added one ListLink. ending_size = self.atomspace.size() self.assertEquals(ending_size, starting_size + 1) # The ListLink should have three items in it. atom = self.atomspace[result] self.assertEquals(atom.arity, 3) self.assertEquals(atom.type, types.ListLink)
# change the atomspace. starting_size = atomspace.size() # Run bindlink. result = stub_bindlink(atomspace, bindlink_handle) assert_true(result is not None and result.value() > 0) # Check the ending atomspace size, it should be the same. ending_size = atomspace.size() assert_equals(ending_size, starting_size) # Remember the starting atomspace size. starting_size = atomspace.size() # Run bindlink. result = bindlink(atomspace, bindlink_handle) assert_true(result is not None and result.value() > 0) # Check the ending atomspace size, it should have added one SetLink. ending_size = atomspace.size() assert_equals(ending_size, starting_size + 1) # The SetLink should have three items in it. atom = atomspace[result] assert_equals(atom.arity, 3) assert_equals(atom.type, types.SetLink) result = execute_atom( atomspace, ExecutionOutputLink(GroundedSchemaNode("py: add_link"), ListLink(ConceptNode("one"), ConceptNode("two"))))
initialize_opencog(atomspace) inp = InputModule(ConceptNode("image"), torch.tensor([1.])) InheritanceLink(ConceptNode("red"), ConceptNode("color")) InheritanceLink(ConceptNode("green"), ConceptNode("color")) net1 = AttentionModule(ConceptNode("red")) net2 = AttentionModule(ConceptNode("green")) # direct execution proceeds as usual print(net1(inp())) # execution from Atomese prog1 = net1.Exec(inp.Exec()) print(prog1) print(get_cached_value(execute_atom(atomspace, prog1))) prog2 = net2.Exec(inp.Exec()) print(get_cached_value(execute_atom(atomspace, prog2))) bl = BindLink( #TypedVariableNode(VariableNode("$X"), TypeNode("ConceptNode")), VariableNode("$X"), AndLink( InheritanceLink(VariableNode("$X"), ConceptNode("color")), cogModule.Evaluate( VariableNode("$X"), inp.Exec()) #inp.Exec() == cogModule.Execute(ConceptNode("image")) ), VariableNode("$X")) bindlink(atomspace, bl)
def generate_action(self): """ generate and execute the action by behavior tree Now (20150822) we generate action by such a behavior tree: If target block found in atomspace: If target block is attractive(sti is large enough): move to the near place of the target block else: moving 2 units toward yaw = 90 degree For testing, we set a target block(gold, which block id is 14) And we assume the world is superflat world so we only need to move on x-y direction. Note that because the behavior of GSN/GPN, we have to import all schemas(action_schemas.py) in the main script(opencog_initializer.py). Or it will fail to find the function name. TODO: Build random action function: It's for the 'else' part in above behavior tree. This will make the bot behaves more naturally. Add pathfinding technique: so the bot can calculate the procedure to get to the destination. it will be able to move to any place he wants. (ex. place block to jump to a higher place) In Opencog there has been an OCPlanner implementation. It should be possible to migrate the old code. More higher level ways to making decision: For now it's just testing so we only use a simple behavior tree to demo. But in general, we should regard these behavior tree as lower level schemas. And we should use a higher level cognition ways(e.g. OpenPsi) to decide what behavior tree we want to execute. """ result = bindlink(self._atomspace, BindLink( VariableNode("$block"), AndLink( EvaluationLink( PredicateNode("material"), ListLink( VariableNode("$block"), ConceptNode("14") ) ), EvaluationLink( GroundedPredicateNode("py: action_schemas.is_attractive"), ListLink( VariableNode("$block") ) ), EvaluationLink( GroundedPredicateNode("py: action_schemas.move_toward_block"), ListLink( VariableNode("$block") ) ) ), VariableNode("$block") ).h ) print "action_gen: result", Atom(result, self._atomspace) if self._atomspace.get_outgoing(result) == []: print "action_gen: no result, random walk." evaluate_atom(self._atomspace, EvaluationLink( GroundedPredicateNode("py: action_schemas.set_relative_move"), ListLink( NumberNode("90"), NumberNode("2"), ConceptNode("jump") ) ) ) print "action_gen end"
def generate_action(self): # TODO: This documantation is outdated. """ generate and execute the action by behavior tree Now (20150822) we generate action by such a behavior tree: If target block found in atomspace: If target block is attractive(sti is large enough): move to the near place of the target block else: moving 2 units toward yaw = 90 degree For testing, we set a target block(gold, which block id is 14) And we assume the world is superflat world so we only need to move on x-y direction. Note that because the behavior of GSN/GPN, we have to import all schemas(action_schemas.py) in the main script(opencog_initializer.py). Or it will fail to find the function name. TODO: Build random action function: It's for the 'else' part in above behavior tree. This will make the bot behaves more naturally. Add pathfinding technique: so the bot can calculate the procedure to get to the destination. it will be able to move to any place he wants. (ex. place block to jump to a higher place) In Opencog there has been an OCPlanner implementation. It should be possible to migrate the old code. More higher level ways to making decision: For now it's just testing so we only use a simple behavior tree to demo. But in general, we should regard these behavior tree as lower level schemas. And we should use a higher level cognition ways(e.g. OpenPsi) to decide what behavior tree we want to execute. """ # The goal_sucess_rate represents how well a given strategy is working # toward achieving the success of the overall goal it is trying to # achieve. This sucess rate defaults to 0 here, and during the main # goal execution the result is something that is furthering the goal # then it can set this to a higher value. The more successful we are # in satisfying a certain goal, the more likely we are to continue # doing this thing, i.e. if we are in the process of doing something # that takes time and are making progress, don't switch to some other # goal right in the middle of that. goal_success_rate = 0.0 # Read the current goal from atomspace goal = bindlink( self._atomspace, BindLink( VariableList( TypedVariableLink(VariableNode("$goal"), TypeNode("ConceptNode")), ), Link(ConceptNode("CURRENT_GOAL"), VariableNode("$goal")), VariableNode("$goal"))) goal_name = goal.out[0].name print "goal_name: ", goal_name ####################################################################### # Main Action Tree ####################################################################### # This if - elif chain is the main action generation code for the bot. # The chain of if statements here branches off of the currently # selected goal. Inside each if block is code which should further # advance that particular goal for the bot. So for example, on the # gather resources goal, the code looks through the bot's memory for # blocks which are wood/ore/etc and then travels to one of them and # mines it out. if goal_name == "Gather resources": print "action_gen: gather resources." # Find resources: # This bindlink looks through all of the blocks currently in the bot's # memory about the world and returns a list of all the ones that are # just the base wood type (i.e. what trees are made out of, not planks, # slabs, buttons, etc). result = bindlink( self._atomspace, BindLink( VariableList( TypedVariableLink(VariableNode("$block"), TypeNode("StructureNode")), TypedVariableLink(VariableNode("$material"), TypeNode("ConceptNode")), ), AndLink( EvaluationLink( PredicateNode("material"), ListLink(VariableNode("$block"), VariableNode("$material"))), EvaluationLink( PredicateNode("be"), ListLink(VariableNode("$material"), ConceptNode("WOOD_BLOCK"))), EvaluationLink( GroundedPredicateNode( "py: action_schemas.is_attractive"), ListLink(VariableNode("$block"))), EvaluationLink( GroundedPredicateNode( "py: action_schemas.dig_block"), ListLink(VariableNode("$block")))), VariableNode("$block"))) print "action_gen: result", result # If we sucessfully mined out a block of wood we have been very # successful in fulfilling this goal and should continue to try to # mine more unless something else really urgent comes up. If we # failed, then we should try to find something else to do. if result.out != []: goal_success_rate = 5.0 else: goal_success_rate = -5.0 elif goal_name == "Explore": print "action_gen: random walk." # Random walk: # Choose a random direction and walk a short distance in that direction and # either execute a normal walk or a walk + jump in that direction. evaluate_atom( self._atomspace, EvaluationLink( GroundedPredicateNode( "py: action_schemas.set_relative_move"), ListLink( RandomChoiceLink( NumberNode("0"), NumberNode("45"), NumberNode("90"), NumberNode("135"), NumberNode("180"), NumberNode("225"), NumberNode("270"), NumberNode("315"), ), RandomChoiceLink( NumberNode("1"), NumberNode("2"), NumberNode("3"), NumberNode("4"), ), ConceptNode("jump")))) goal_success_rate = 1.0 elif goal_name == "Look around": print "action_gen: look around." # Random walk: # Choose a random direction and walk 1 block in that direction and # either execute a normal walk or a walk + jump in that direction. evaluate_atom( self._atomspace, EvaluationLink( GroundedPredicateNode( "py: action_schemas.set_relative_look"), ListLink( RandomChoiceLink( NumberNode("0"), NumberNode("90"), NumberNode("180"), NumberNode("270"), ), NumberNode("0")))) goal_success_rate = 0.5 else: # If we got here then there was no handler coded yet for the # currently selected goal. Return a very negative # goal_success_rate so that we switch to another goal since # standing around doing nothing is not productive. goal_success_rate = -20.0 # Decide whether or not we should change the current goal, or if we # should keep doing the same thing in the next time step. print "It has been %s time steps since the goal was changed." % self.steps_since_goal_change # Make it more and more likely to change the current goal depending on # how long we have been on the current goal. if random.normalvariate(0.0, 1.0) >= 1.5 - 0.1 * \ self.steps_since_goal_change + 0.1 * goal_success_rate: print "\n\n\n\t\t\tChanging current goal\n\n\n" self.steps_since_goal_change = 1 # Get the full list of all the goals in the atomspace goal_atoms = bindlink( self._atomspace, BindLink( TypedVariableLink(VariableNode("$goal"), TypeNode("ConceptNode")), EvaluationLink( PredicateNode("be"), ListLink(ConceptNode("GOAL"), VariableNode("$goal")), ), VariableNode("$goal"))) # print "All goals: ", goal_atoms_list goal_atoms_list = goal_atoms.out # TODO: This should be done in atomese. random_goal = goal_atoms_list[random.randint( 0, len(goal_atoms_list) - 1)] print "Random goal: ", random_goal # delete the existing CURRENT_GOAL link and then # create a new one pointing to the newly chosen goal. self._atomspace.remove( Link(ConceptNode("CURRENT_GOAL"), ConceptNode(goal_name))) self._atomspace.add_link( types.Link, (ConceptNode("CURRENT_GOAL"), random_goal)) else: self.steps_since_goal_change += 1 print "action_gen end"
def generate_action(self): """ generate and execute the action by behavior tree Now (20150822) we generate action by such a behavior tree: If target block found in atomspace: If target block is attractive(sti is large enough): move to the near place of the target block else: moving 2 units toward yaw = 90 degree For testing, we set a target block(gold, which block id is 14) And we assume the world is superflat world so we only need to move on x-y direction. Note that because the behavior of GSN/GPN, we have to import all schemas(action_schemas.py) in the main script(opencog_initializer.py). Or it will fail to find the function name. TODO: Build random action function: It's for the 'else' part in above behavior tree. This will make the bot behaves more naturally. Add pathfinding technique: so the bot can calculate the procedure to get to the destination. it will be able to move to any place he wants. (ex. place block to jump to a higher place) In Opencog there has been an OCPlanner implementation. It should be possible to migrate the old code. More higher level ways to making decision: For now it's just testing so we only use a simple behavior tree to demo. But in general, we should regard these behavior tree as lower level schemas. And we should use a higher level cognition ways(e.g. OpenPsi) to decide what behavior tree we want to execute. """ result = bindlink(self._atomspace, BindLink( VariableList( TypedVariableLink( VariableNode("$block"), TypeNode("StructureNode") ), TypedVariableLink( VariableNode("$material"), TypeNode("ConceptNode") ), ), AndLink( EvaluationLink( PredicateNode("material"), ListLink( VariableNode("$block"), VariableNode("$material") ) ), EvaluationLink( PredicateNode("be"), ListLink( VariableNode("$material"), ConceptNode("WOOD_BLOCK") ) ), EvaluationLink( GroundedPredicateNode("py: action_schemas.is_attractive"), ListLink( VariableNode("$block") ) ), EvaluationLink( GroundedPredicateNode("py: action_schemas.dig_block"), ListLink( VariableNode("$block") ) ) ), VariableNode("$block") ).h ) print "action_gen: result", Atom(result, self._atomspace) if self._atomspace.get_outgoing(result) == []: print "action_gen: no result, random walk." evaluate_atom(self._atomspace, EvaluationLink( GroundedPredicateNode("py: action_schemas.set_relative_move"), ListLink( RandomChoiceLink( NumberNode("0"), NumberNode("90"), NumberNode("180"), NumberNode("270"), ), NumberNode("1"), ConceptNode("jump") ) ) ) print "action_gen end"
def test_bind(atomspace, prep_atom): n = 10000 for i in xrange(n): result = bindlink(atomspace, prep_atom) return n
def test_bindlink(self): atom = bindlink(self.atomspace, self.bindlink_atom) self._check_result_setlink(atom, 3)
# change the atomspace. starting_size = atomspace.size() # Run bindlink. result = stub_bindlink(atomspace, bindlink_atom) assert_true(result is not None) # Check the ending atomspace size, it should be the same. ending_size = atomspace.size() assert_equals(ending_size, starting_size) # Remember the starting atomspace size. starting_size = atomspace.size() # Run bindlink. result = bindlink(atomspace, bindlink_atom) assert_true(result is not None) # Check the ending atomspace size, it should have added one SetLink. ending_size = atomspace.size() assert_equals(ending_size, starting_size + 1) # The SetLink should have three items in it. assert_equals(result.arity, 3) assert_equals(result.type, types.SetLink) result = execute_atom(atomspace, ExecutionOutputLink( GroundedSchemaNode("py: add_link"), ListLink( ConceptNode("one"),
# change the atomspace. starting_size = atomspace.size() # Run bindlink. result = stub_bindlink(atomspace, bindlink_atom) assert_true(result is not None) # Check the ending atomspace size, it should be the same. ending_size = atomspace.size() assert_equals(ending_size, starting_size) # Remember the starting atomspace size. starting_size = atomspace.size() # Run bindlink. result = bindlink(atomspace, bindlink_atom) assert_true(result is not None) # Check the ending atomspace size, it should have added one SetLink. ending_size = atomspace.size() assert_equals(ending_size, starting_size + 1) # The SetLink should have three items in it. assert_equals(result.arity, 3) assert_equals(result.type, types.SetLink) result = execute_atom( atomspace, ExecutionOutputLink(GroundedSchemaNode("py: add_link"), ListLink(ConceptNode("one"), ConceptNode("two")))) list_link = ListLink(ConceptNode("one"), ConceptNode("two"))
def generate_action(self): # TODO: This documantation is outdated. """ generate and execute the action by behavior tree Now (20150822) we generate action by such a behavior tree: If target block found in atomspace: If target block is attractive(sti is large enough): move to the near place of the target block else: moving 2 units toward yaw = 90 degree For testing, we set a target block(gold, which block id is 14) And we assume the world is superflat world so we only need to move on x-y direction. Note that because the behavior of GSN/GPN, we have to import all schemas(action_schemas.py) in the main script(opencog_initializer.py). Or it will fail to find the function name. TODO: Build random action function: It's for the 'else' part in above behavior tree. This will make the bot behaves more naturally. Add pathfinding technique: so the bot can calculate the procedure to get to the destination. it will be able to move to any place he wants. (ex. place block to jump to a higher place) In Opencog there has been an OCPlanner implementation. It should be possible to migrate the old code. More higher level ways to making decision: For now it's just testing so we only use a simple behavior tree to demo. But in general, we should regard these behavior tree as lower level schemas. And we should use a higher level cognition ways(e.g. OpenPsi) to decide what behavior tree we want to execute. """ # The goal_sucess_rate represents how well a given strategy is working # toward achieving the success of the overall goal it is trying to # achieve. This sucess rate defaults to 0 here, and during the main # goal execution the result is something that is furthering the goal # then it can set this to a higher value. The more successful we are # in satisfying a certain goal, the more likely we are to continue # doing this thing, i.e. if we are in the process of doing something # that takes time and are making progress, don't switch to some other # goal right in the middle of that. goal_success_rate = 0.0 # Read the current goal from atomspace goal = bindlink(self._atomspace, BindLink( VariableList( TypedVariableLink( VariableNode("$goal"), TypeNode("ConceptNode") ), ), Link( ConceptNode("CURRENT_GOAL"), VariableNode("$goal") ), VariableNode("$goal") ) ) goal_name = goal.out[0].name print "goal_name: ", goal_name ####################################################################### # Main Action Tree ####################################################################### # This if - elif chain is the main action generation code for the bot. # The chain of if statements here branches off of the currently # selected goal. Inside each if block is code which should further # advance that particular goal for the bot. So for example, on the # gather resources goal, the code looks through the bot's memory for # blocks which are wood/ore/etc and then travels to one of them and # mines it out. if goal_name == "Gather resources": print "action_gen: gather resources." # Find resources: # This bindlink looks through all of the blocks currently in the bot's # memory about the world and returns a list of all the ones that are # just the base wood type (i.e. what trees are made out of, not planks, # slabs, buttons, etc). result = bindlink(self._atomspace, BindLink( VariableList( TypedVariableLink( VariableNode("$block"), TypeNode("StructureNode") ), TypedVariableLink( VariableNode("$material"), TypeNode("ConceptNode") ), ), AndLink( EvaluationLink( PredicateNode("material"), ListLink( VariableNode("$block"), VariableNode("$material") ) ), EvaluationLink( PredicateNode("be"), ListLink( VariableNode("$material"), ConceptNode("WOOD_BLOCK") ) ), EvaluationLink( GroundedPredicateNode( "py: action_schemas.is_attractive"), ListLink( VariableNode("$block") ) ), EvaluationLink( GroundedPredicateNode( "py: action_schemas.dig_block"), ListLink( VariableNode("$block") ) ) ), VariableNode("$block") ) ) print "action_gen: result", result # If we sucessfully mined out a block of wood we have been very # successful in fulfilling this goal and should continue to try to # mine more unless something else really urgent comes up. If we # failed, then we should try to find something else to do. if result.out != []: goal_success_rate = 5.0 else: goal_success_rate = -5.0 elif goal_name == "Explore": print "action_gen: random walk." # Random walk: # Choose a random direction and walk a short distance in that direction and # either execute a normal walk or a walk + jump in that direction. evaluate_atom(self._atomspace, EvaluationLink( GroundedPredicateNode( "py: action_schemas.set_relative_move"), ListLink( RandomChoiceLink( NumberNode("0"), NumberNode("45"), NumberNode("90"), NumberNode("135"), NumberNode("180"), NumberNode("225"), NumberNode("270"), NumberNode("315"), ), RandomChoiceLink( NumberNode("1"), NumberNode("2"), NumberNode("3"), NumberNode("4"), ), ConceptNode("jump") ) ) ) goal_success_rate = 1.0 elif goal_name == "Look around": print "action_gen: look around." # Random walk: # Choose a random direction and walk 1 block in that direction and # either execute a normal walk or a walk + jump in that direction. evaluate_atom(self._atomspace, EvaluationLink( GroundedPredicateNode( "py: action_schemas.set_relative_look"), ListLink( RandomChoiceLink( NumberNode("0"), NumberNode("90"), NumberNode("180"), NumberNode("270"), ), NumberNode("0") ) ) ) goal_success_rate = 0.5 else: # If we got here then there was no handler coded yet for the # currently selected goal. Return a very negative # goal_success_rate so that we switch to another goal since # standing around doing nothing is not productive. goal_success_rate = -20.0 # Decide whether or not we should change the current goal, or if we # should keep doing the same thing in the next time step. print "It has been %s time steps since the goal was changed." % self.steps_since_goal_change # Make it more and more likely to change the current goal depending on # how long we have been on the current goal. if random.normalvariate(0.0, 1.0) >= 1.5 - 0.1 * \ self.steps_since_goal_change + 0.1 * goal_success_rate: print "\n\n\n\t\t\tChanging current goal\n\n\n" self.steps_since_goal_change = 1 # Get the full list of all the goals in the atomspace goal_atoms = bindlink(self._atomspace, BindLink( TypedVariableLink( VariableNode("$goal"), TypeNode("ConceptNode") ), EvaluationLink( PredicateNode("be"), ListLink( ConceptNode("GOAL"), VariableNode("$goal") ), ), VariableNode("$goal") )) # print "All goals: ", goal_atoms_list goal_atoms_list = goal_atoms.out # TODO: This should be done in atomese. random_goal = goal_atoms_list[ random.randint(0, len(goal_atoms_list) - 1)] print "Random goal: ", random_goal # delete the existing CURRENT_GOAL link and then # create a new one pointing to the newly chosen goal. self._atomspace.remove( Link( ConceptNode("CURRENT_GOAL"), ConceptNode(goal_name))) self._atomspace.add_link( types.Link, (ConceptNode("CURRENT_GOAL"), random_goal)) else: self.steps_since_goal_change += 1 print "action_gen end"
# change the atomspace. starting_size = atomspace.size() # Run bindlink. result = stub_bindlink(atomspace, bindlink_handle) assert_true(result is not None and result.value() > 0) # Check the ending atomspace size, it should be the same. ending_size = atomspace.size() assert_equals(ending_size, starting_size) # Remember the starting atomspace size. starting_size = atomspace.size() # Run bindlink. result = bindlink(atomspace, bindlink_handle) assert_true(result is not None and result.value() > 0) # Check the ending atomspace size, it should have added one SetLink. ending_size = atomspace.size() assert_equals(ending_size, starting_size + 1) # The SetLink should have three items in it. atom = atomspace[result] assert_equals(atom.arity, 3) assert_equals(atom.type, types.SetLink) result = execute_atom(atomspace, ExecutionOutputLink( GroundedSchemaNode("py: add_link"), ListLink(
print(get_cached_value(execute_atom(atomspace, prog1))) prog2 = net2.execute(inp.execute()) print(get_cached_value(execute_atom(atomspace, prog2))) bl = BindLink( TypedVariableLink(VariableNode("$X"), TypeNode("ConceptNode")), #VariableNode("$X"), AndLink( InheritanceLink(VariableNode("$X"), ConceptNode("color")), evaluate( VariableNode("$X"), inp.execute()) #inp.execution() == execute(ConceptNode("image")) ), VariableNode("$X")) print(bindlink(atomspace, bl)) # ---------------- # wrapping torch.tensor tv to make it trainable # class TensorTVModule(cogModule): class InheritanceModule(CogModule): def __init__(self, atom, init_tv): super().__init__(atom) self.tv = init_tv def forward(self): return self.tv