from xapian import InvalidOperationError __author__ = 'Keyvan' from opencog.atomspace import TruthValue DEFAULT_TRUTH_VALUE = TruthValue(1, 1) class Marker(object): # Marker Class, usually used for marking! pass class OtherThan(object): def __init__(self, seq): self.seq = seq def __eq__(self, other): for item in self.seq: if other == item: return False return True def __ne__(self, other): return not self.__eq__(other) marker = Marker() # A Marker def subsets_of_len_two(seq): indexed_seq = list(seq)
def look_at_face(face_id_node): face_id = int(float(face_id_node.name)) # print "Python look at face id", face_id evl.look_at(face_id) return TruthValue(1, 1)
def look_at_point(x_node, y_node, z_node): x = float(x_node.name) y = float(y_node.name) z = float(z_node.name) evl.look_at_point(x, y, z) return TruthValue(1, 1)
def blink_rate(mean_node, var_node): mean = float(mean_node.name) var = float(var_node.name) # print "Python: blink-rate: ", mean, " variation ", var evl.blink_rate(mean, var) return TruthValue(1, 1)
def do_wake_up(): evl.wake_up() return TruthValue(1, 1)
def test_add_nodes_large(atomspace, prep_atom): """Add n nodes in atomspace with python bindings""" n = 500000 for i in xrange(n): atomspace.add_node(types.ConceptNode, str(i), TruthValue(.5, .5)) return n
def explore_saccade(): # print "Python: Explore Saccade" evl.explore_saccade() return TruthValue(1, 1)
def notice_changes(atomspace): tv_delta = 0.000001 t = types times = atomspace.get_atoms_by_type(t.TimeNode) times = [f for f in times if f.name != "0"] # Related to a bug in the Psi Modulator system times = sorted(times, key= lambda t: int(t.name) ) target_PredicateNodes = [x for x in atomspace.get_atoms_by_type(t.PredicateNode) if "DemandGoal" in x.name] for atom in target_PredicateNodes: target = T('EvaluationLink', [atom]) # find all of the xDemandGoal AtTimeLinks in order, sort them, then check whether each one is higher/lower than the previous one. atTimes = [] times_with_update = [] for time in times: # # Need to use unify because not sure what the arguments will be. But they must be the same... # template = Tree('AtTimeLink', target, time) # matches = find_conj( (template,) ) # # # If this DemandGoal is in use there will be one value at each timestamp (otherwise none) # assert len(matches) < 2 # matches[0]. template = T('AtTimeLink', [target, time]) a = atom_from_tree(template, atomspace) # Was the value updated at that timestamp? The PsiDemandUpdaterAgent is not run every cycle so many # timestamps will have no value recorded. if a.tv.count > 0: atTimes.append(a) times_with_update.append(time) if len(atTimes) < 2: continue for i, atTime in enumerate(atTimes[:-1]): atTime_next = atTimes[i+1] tv1 = atTime.tv.mean tv2 = atTime_next.tv.mean #print tv2-tv1 if tv2 - tv1 > tv_delta: # increased pred = 'increased' elif tv1 - tv2 > tv_delta: # decreased pred = 'decreased' else: continue time2 = times_with_update[i+1] tv = TruthValue(1, 1.0e35) res = T('AtTimeLink', T('EvaluationLink', atomspace.add(t.PredicateNode, name=pred), T('ListLink', target ) ), time2 ) a = atom_from_tree(res, atomspace) a.tv = tv #print str(a) atTime.tv = TruthValue(0, 0)
def publish_behavior(event_node): # print "(Behavior event:", event_node.name, ")" evl.publish_behavior(event_node.name) return TruthValue(1, 1)
def initilization(self, atomspace): ''' Initializes necessary variables. Loads rules. ''' self.atomspace = atomspace self.PleonasticItNode = atomspace.add_node(types.AnchorNode, 'Pleonastic-it', TruthValue(1.0, 100)) self.currentPronounNode = atomspace.add_node(types.AnchorNode, 'CurrentPronoun', TruthValue(1.0, 100)) self.currentTarget = atomspace.add_node(types.AnchorNode, 'CurrentTarget', TruthValue(1.0, 100)) self.currentResult = atomspace.add_node(types.AnchorNode, 'CurrentResult', TruthValue(1.0, 100)) self.currentProposal = atomspace.add_node(types.AnchorNode, 'CurrentProposal', TruthValue(1.0, 100)) self.unresolvedReferences = atomspace.add_node( types.AnchorNode, 'Recent Unresolved references', TruthValue(1.0, 100)) self.resolvedReferences = atomspace.add_node(types.AnchorNode, 'Resolved references', TruthValue(1.0, 100)) self.currentResolutionNode = atomspace.add_node( types.AnchorNode, 'CurrentResolution', TruthValue(1.0, 100)) self.currentResolutionLink_proposal = self.atomspace.add_link( types.ListLink, [self.currentResolutionNode, self.currentProposal], TruthValue(1.0, 100)) self.currentResolutionLink_pronoun = self.atomspace.add_link( types.ListLink, [self.currentResolutionNode, self.currentPronounNode], TruthValue(1.0, 100)) self.pronounNumber = -1 data = [ "opencog/nlp/anaphora/rules/getChildren.scm", "opencog/nlp/anaphora/rules/getNumberNode_WordInstanceNode.scm", "opencog/nlp/anaphora/rules/getNumberNode_ParseNode.scm", "opencog/nlp/anaphora/rules/connectRootsToParseNodes.scm", "opencog/nlp/anaphora/rules/getAllNumberNodes.scm", "opencog/nlp/anaphora/rules/getAllParseNodes.scm", "opencog/nlp/anaphora/rules/getConjunction.scm", "opencog/nlp/anaphora/rules/getParseNode.scm", "opencog/nlp/anaphora/rules/getWords.scm", "opencog/nlp/anaphora/rules/isIt.scm", "opencog/nlp/anaphora/rules/filtersGenerator.scm", "opencog/nlp/anaphora/rules/filters/filter-#1.scm", "opencog/nlp/anaphora/rules/filters/filter-#2.scm", "opencog/nlp/anaphora/rules/filters/filter-#3.scm", "opencog/nlp/anaphora/rules/filters/filter-#4.scm", "opencog/nlp/anaphora/rules/filters/filter-#5.scm", "opencog/nlp/anaphora/rules/filters/filter-#6.scm", "opencog/nlp/anaphora/rules/filters/filter-#7.scm", "opencog/nlp/anaphora/rules/filters/filter-#8.scm", "opencog/nlp/anaphora/rules/filters/filter-#9.scm", "opencog/nlp/anaphora/rules/filters/filter-#10.scm", "opencog/nlp/anaphora/rules/filters/filter-#11.scm", "opencog/nlp/anaphora/rules/filters/filter-#12.scm", "opencog/nlp/anaphora/rules/filters/filter-#13.scm", "opencog/nlp/anaphora/rules/filters/filter-#14.scm", "opencog/nlp/anaphora/rules/filters/filter-#15.scm", "opencog/nlp/anaphora/rules/filters/filter-#16.scm", "opencog/nlp/anaphora/rules/filters/filter-#17.scm", "opencog/nlp/anaphora/rules/filters/filter-#18.scm", "opencog/nlp/anaphora/rules/pre-process/pre-process-#1.scm", "opencog/nlp/anaphora/rules/pre-process/pre-process-#2.scm", "opencog/nlp/anaphora/rules/pre-process/pre-process-#3.scm", "opencog/nlp/anaphora/rules/pleonastic-it/pleonastic-it-#1.scm", "opencog/nlp/anaphora/rules/pleonastic-it/pleonastic-it-#2.scm", "opencog/nlp/anaphora/rules/pleonastic-it/pleonastic-it-#3.scm", ] self.numOfFilters = 20 self.numOfPrePatterns = 3 self.numOfPleonasticItPatterns = 3 for item in data: load_scm(atomspace, item) self.getAllNumberNodes() self.pronouns = self.getTargets(self.getWords()) self.roots = self.getRoots()
def output_causal_implications_for_last_layer(self, layers): if len(layers) < 2: return layer = layers[-1] prev_layer = layers[-2] for (ptn, embs) in layer: conj = list(ptn.conj) seqs = list(ptn.seqs) if len(seqs) < 2: continue conclusion = seqs[-1] other = seqs[:-1] assert len(other) # Remove all of the AtTimeLinks from inside the sequence - just leave # the EvaluationLinks/ExecutionLinks. The AtTimeLinks are not # required/allowed if you have SequentialAndLinks etc. This won't change # the Pattern that Fishgram is storing - Fishgram's search does need # the AtTimeLinks. conclusion_stripped = conclusion.args[1] other_stripped = [attime.args[1] for attime in other] # There are several special cases to simplify the Link produced. if len(other_stripped) > 1: # NOTE: this won't work if some of the things are simultaneous initial = Tree('SequentialAndLink',other_stripped) else: initial = other_stripped[0] predimp = T ('PredictiveImplicationLink', initial, conclusion_stripped ) if len(conj) > 0: imp = T('ImplicationLink', Tree('AndLink', conj), predimp) payload = imp else: payload = predimp vars = get_varlist( conj + other_stripped + [conclusion_stripped] ) assert len(vars) rule = T('AverageLink', T('ListLink',vars), payload ) # Calculate the frequency. Looking up embeddings only works if you keep the # AtTimeLinks. premises = conj + other premises_embs = self.forest.lookup_embeddings(premises) freq = len(embs) / len(premises_embs) a = atom_from_tree(rule, self.atomspace) self.rules_output.append(rule) a.tv = TruthValue(freq, len(embs))
the ith accepted candidate will have confidence value of (x^(i-1))(1-x) i starts at 1. ''' CONFIDENCE_DECREASING_RATE = 0.7 ''' Strength for accepted antecedents ''' STRENGTH_FOR_ACCEPTED_ANTECEDENTS = 0.98 ''' Truth Value for antecendents which have been filtered out by filters. ''' TV_FOR_FILTERED_OUT_ANTECEDENTS = TruthValue( 0.02, TruthValue().confidence_to_count(0.9)) ''' ======================================== ''' class BindLinkExecution(): ''' Executes a (cog-bind xxx) command and return the results of it ''' def __init__(self, atomspace, anchorNode, target, command, resultNode, atomType): ''' Stores necessary information '''
def test_creation(self): a = Node("test1") self.assertEqual(a.name, "test1") self.assertEqual(a.tv, TruthValue(1.0, 0.0)) # default is true, no confidence
def test_creation(self): a = self.space.add_node(types.Node, "test1") self.assertEqual(a.name, "test1") self.assertEqual(a.tv, TruthValue(0.0, 0.0))
def prep_traverse_1M(atomspace): """Add n nodes in atomspace with python bindings""" n = 1000000 for i in xrange(n): atomspace.add_node(types.ConceptNode, str(i), TruthValue(.5, .5)) return n, atomspace.get_atoms_by_type(types.ConceptNode)
def listening_saccade(): # print "Python: Listening Saccade" evl.listening_saccade() return TruthValue(1, 1)
def prep_get_100K(atomspace): """Add n nodes in atomspace with python bindings""" n = 100000 for i in xrange(n): atomspace.add_node(types.ConceptNode, str(i), TruthValue(.5, .5)) return n
def say_text(text_node): text = text_node.name evl.say_text(text) return TruthValue(1, 1)
def test_creation(self): a = self.space.add_node(types.Node, "test1") self.assertEqual(a.name, "test1") self.assertEqual(a.tv, TruthValue(1.0, 0.0)) # default is true, no confidence
def bogus_tv(atom_one, atom_two) : return TruthValue(0.6, 0.234)
def conversational_saccade(): # print "Python: Conversational Saccade" evl.conversational_saccade() return TruthValue(1, 1)
def run(self,atomspace): attentional_focus = get_attentional_focus(atomspace) for node1 in attentional_focus: for node2 in attentional_focus: if node1 == node2: continue print atomspace.add_edge(types.AsymmetricHebbianLink, [node1, node2], TruthValue(0.5,1))
def ros_is_running(): if (rospy.is_shutdown()): return TruthValue(0, 1) return TruthValue(1, 1)
def load_scm_file(a, filename): log.info("loading...") tree = Viz_Graph() ident_stack = [] atom_stack = [] root = None define_dict = {} try: f = open(filename, "r") for line_no, line in enumerate(f.readlines()): # code... ## parase scheme file line by line ## parase "define" temp = line.strip('\n ()') if temp.startswith('define'): temp = temp.split(' ') define_dict[temp[1]] = temp[2] continue ## if line.startswith('('): if tree.number_of_nodes() > 0: # deal with previous segment add_tree_to_atomspace(a, tree, root) tree.clear() # ident_stack[:] = [] atom_stack[:] = [] ## parase a new segment name = "" t = "" stv = None av = {} ident = line.find("(") if ident != -1: #log.debug(line.strip('\n')) ident_stack.append(ident) # the first: type name # the second: stv or av # the third: stv or av l = line line = line.strip(' ') line = line.strip('\n') elms = line.split('(') first = elms[1] try: second = elms[2] second = second.split(')')[0] second = dict_sub(second, define_dict) except Exception: second = None try: third = elms[3] third = third.split(')')[0] third = dict_sub(third, define_dict) except Exception: third = None #log.debug("********************" ) #log.debug("first:%s*"%first) #log.debug("second:%s*"%second) #log.debug("third:%s*"%third) #log.debug("********************" ) if second: second = second.strip() if second.find("av") != -1: temp = second.split(" ") av['sti'] = float(temp[1]) av['lti'] = float(temp[2]) av['vlti'] = float(temp[3]) elif second.find("stv") != -1: temp = second.split(" ") mean = float(temp[1]) confidence = float(temp[2]) # the value to stv! stv = TruthValue(mean, confidence_to_count(confidence)) if third: third = third.strip() if third.find("av") != -1: temp = third.split(" ") av['sti'] = float(temp[1]) av['lti'] = float(temp[2]) av['vlti'] = float(temp[3]) elif third.find("stv") != -1: temp = third.split(" ") mean = float(temp[1]) confidence = float(temp[2]) # the value to stv! stv = TruthValue(mean, confidence_to_count(confidence)) try: t = first[0:first.index(' ')] name = first[first.index(' ') + 1:-1].strip('"') #log.debug("**********atom**************" ) #log.debug("type: %s"%t+"*" ) #log.debug("name: %s"%name+"*") #log.debug("stv: %s"%stv) #log.debug("av: %s"%av) #log.debug("*****************************" ) except Exception: t = first.strip(' ') ## add nodes to segment tree is_node = True if name else False if is_node: # node try: node = FakeAtom(name_type_dict[t], name, stv, av) except KeyError: log.error( "Unknown Atom type '%s' in line %s, pls add related type infomation to file 'types_inheritance.py' and OpenCog" % (t, line_no)) raise KeyError uni_node_id = tree.unique_id(name) tree.add_node(uni_node_id, atom=node) atom_stack.append(node) if l.startswith('('): root = uni_node_id else: # link uni_link_id = tree.unique_id(t) #print "link:%s**"%t try: link = FakeAtom(name_type_dict[t], uni_link_id, stv, av) except KeyError: log.error("Unknown Atom type '%s' in line %s" % (t, line_no)) raise KeyError atom_stack.append(link) tree.add_node(uni_link_id, atom=link) if l.startswith('('): root = uni_link_id ## add an edge(between link and node, or link to sub_link) to the segment tree now = ident_stack[-1] for i, prev_ident in reversed(list(enumerate(ident_stack))): if now > prev_ident: ## the ith is parent, the link if is_node: log.debug("%s -> %s" % (atom_stack[i].name, uni_node_id)) tree.add_edge(atom_stack[i].name, uni_node_id) else: log.debug("%s -> %s" % (atom_stack[i].name, uni_link_id)) tree.add_edge(atom_stack[i].name, uni_link_id) ## set the 'order' attribute tree.get_node_attr(atom_stack[i].name).setdefault( 'order', -1) tree.get_node_attr(atom_stack[i].name)['order'] += 1 order = tree.get_node_attr(atom_stack[i].name)['order'] if is_node: tree.set_edge_attr(atom_stack[i].name, uni_node_id, order=order) else: tree.set_edge_attr(atom_stack[i].name, uni_link_id, order=order) break ## deal with the last segment if tree.number_of_nodes() > 0: add_tree_to_atomspace(a, tree, root) tree.clear() log.info("loaded scm file sucessfully!") except IOError: log.error("failed to read file %s " % filename) raise IOError else: f.close()
def do_go_sleep(): evl.go_sleep() return TruthValue(1, 1)
def move_toward_block(block_atom): """ Make bot move near the block. If there's no surrounding block info, the bot may find no place to stand on and stop moving. Also if there's no empty place near ( distance <= 2) the block, the bot will not move. Args: block_atom(opencog.atomspace.Atom): The atom representing block, towards which bot is made to move. Returns: TruthValue(1,1) if move success else TruthValue(0,1). TODO: Make it faster: the calculation of near place is slow. Add distance argument: make caller control the judgement of "near" """ print 'move toward atom', block_atom # Get the block position info from the atomspace, to do this we query # spacemap. jump = False map_handle = (atomspace.get_atoms_by_name( types.SpaceMapNode, "MCmap")[0]).h cur_map = space_server.get_map(map_handle) cur_er = space_server.get_entity_recorder(map_handle) block_pos = cur_map.get_block_location(block_atom.h) # If we did not find the block in the spacemap than return false, otherwise # continue the function. if block_pos is None: print 'block position not found.', block_atom return TruthValue(0, 1) # Try to find an open block we can stand on near the target block. dest = get_near_free_point( atomspace, cur_map, block_pos, 2, (1, 0, 0), True) if dest is None: print 'get_no_free_point' print 'block_pos, dest', block_pos, dest # Get the position of the bot. self_handle = cur_er.get_self_agent_entity() self_pos = cur_er.get_last_appeared_location(self_handle) # Check to see if we are already standing where we want, if so then we are # done, otherwise actually pass the move call along to ROS. if (math.floor(self_pos[0]) == dest[0] and math.floor(self_pos[1]) == dest[1] and math.floor(self_pos[2]) == dest[2]): print 'has arrived there' return TruthValue(1, 1) else: # Pass the call to ROS and return its success value back to the caller of this function. # TODO: In Minecraft the up/down direction is y coord # but we should swap y and z in ros node, not here.. response = _ros_set_move(block_pos[0], block_pos[1], jump) # TODO: The AI is expected to finish a full step in less than 1 second, # so we should figure out a better value for this wait timer. rospy.sleep(1) print 'action_schemas: abs_move response', response if response.state: print 'move success' return TruthValue(1, 1) else: print 'move fail' return TruthValue(0, 1)
def gaze_at_face(face_id_node): face_id = int(float(face_id_node.name)) print "Python gaze at face id", face_id evl.gaze_at(face_id) return TruthValue(1, 1)
def _tv_from_dict(d): stv_dict = d['simple'] return TruthValue(stv_dict['str'], stv_dict['count'])
__author__ = 'keyvan&ramin' from opencog.atomspace import AtomSpace, TruthValue import quad_reader DEFAULT_TV = TruthValue(1, 1) def map_from_path(quad_dump_path, atomspace): quads = quad_reader.extract_quads(quad_dump_path) for quad in quads: try: value = int(quad.value) value_node_type = 'NumberNode' except: value_node_type = 'ConceptNode' if quad.value is None: atomspace.add_link('EvaluationLink', [ atomspace.add_node('PredicateNode', quad.predicate, DEFAULT_TV), atomspace.add_link('ListLink', [ atomspace.add_node('ObjectEntityNode', quad.subject, DEFAULT_TV), atomspace.add_node('ObjectEntityNode', quad.destination, DEFAULT_TV) ]) ]) elif quad.destination is None: atomspace.add_link('EvaluationLink', [ atomspace.add_node('PredicateNode', quad.predicate,
# OpenCog from opencog.atomspace import AtomSpace, TruthValue from opencog.atomspace import types from opencog.atomspace import get_type, is_a from opencog.exec import execute_atom from opencog.type_constructors import * from opencog.spacetime import * from opencog.pln import * from opencog.utilities import is_closed, get_free_variables from opencog.logger import Logger, log, create_logger ############# # Constants # ############# TRUE_TV = TruthValue(1, 1) DEFAULT_TV = TruthValue(1, 0) ############# # Variables # ############# agent_log = create_logger("opencog.log") agent_log.set_component("Agent") ############# # Functions # ############# def has_non_null_confidence(atom):