Example #1
0
 def learn_concept(self, word, percept_data):
     """ learn a concept (word + percept)
     """
     # if word is already know, update perceptual data
     if self.lex.check_word(word):
         cs_tag = self.cs_lex.get_h_tag(word)
         self.cs.get_concept(cs_tag).add_data(percept_data)
     
     # if word is not known, create new concept
     else:
         self.lex.add_word(word)                 # create word in lexicon
         self.lex_lex.create_node(word)          # create lex node in lex_lex
         self.lex_lex.add_link(word, word)       # add link between lex and lex node
         cs_list = []                            # create list of percept tags
         for i in percept_data:
             cs_tag = "no_tag"
             while ((cs_tag == "no_tag") or (cs_tag in self.cs.concept_tags)): # make sure the cs_tag is unique
                 cs_tag = auks.generateRandomTag(6)
             cs_list.append(cs_tag)
             self.cs.create_pconcept(cs_tag, [i])      # create pconcept in CS  
             self.cs_cs.create_node(cs_tag)          # create cs node in cs_cs
             self.cs_cs.add_link(cs_tag, cs_tag)     # add link between cs and cs node
             self.cs_lex.add_link(cs_tag, word)      # add link between lex and cs matrix
         
         self.n_percepts = len(self.cs.concepts)     # update numbers
         self.n_words = len(self.lex.words)
             
         if len(cs_list) > 1 and cfg.associative_object_learning:
             while len(cs_list) > 1:
                 self.cs_cs.add_link(cs_list[0], cs_list[1])
                 self.cs_cs.add_link(cs_list[1], cs_list[0])
                 cs_list = cs_list[1:]
Example #2
0
def discrimination_game(agent, context, topic_index):
    """ Discrimination game in which an agent has to distinguish the topic
        from the context. The game succeeds if the agent has a concept 
        which uniquely matches the topic and no other stimuli from the context.
        If this is not the case, a new concept is build, or the existing concepts
        are shifted.
        context = sets of data [  [[ "domain", [ [d1, value], [d2, value], ..., [dn, value] ]], ..., ]]
                               [  [["c", [ ["r",1.0], ["g",0.0], ["b",0.0]]]]]
    """
    # if agent knowledge is empty, create new percept and concept
    if agent.cs.concepts == []:
        cs_tag = auks.generateRandomTag(6)
        agent.cs.create_pconcept(cs_tag, context[topic_index])
        agent.cs_cs.create_node(cs_tag)              # create cs node in cs_cs matrix
        agent.cs_cs.add_link(cs_tag, cs_tag)         # add link between cs and cs nod
        answer = cs_tag
    else:
        best_matching_percepts = []
        for i in context:
            best_matching_percepts.append(agent.cs.get_closest_concept_tag(i))
            
        # determine the outcome of the discrimination game
        if best_matching_percepts.count(best_matching_percepts[topic_index]) == 1:
            success = True
            agent.n_success_dg += 1.0
            answer = best_matching_percepts[topic_index]
            agent.cs.set_concept_disc_use(best_matching_percepts[topic_index], 1)
        else:
            agent.cs.set_concept_disc_use(best_matching_percepts[topic_index], 0)
            # if agent discrimination success is below threshold a new percept is created
            if agent.discrimination_success < cfg.adapt_threshold:
                cs_tag = auks.generateRandomTag(6)
                agent.cs.create_pconcept(cs_tag, context[topic_index])
                agent.cs_cs.create_node(cs_tag)              # create cs node in cs_cs matrix
                agent.cs_cs.add_link(cs_tag, cs_tag)         # add link between cs and cs nod
                answer = cs_tag
            # else, the best matching percept is shifted towards the topic
            else:
                cs_tag = best_matching_percepts[topic_index]
                agent.cs.get_concept(cs_tag).add_data(context[topic_index])
                #agent.cs.get_concept(cs_tag).move_to(context[topic_index])
                answer = cs_tag
        agent.n_discrimination_games += 1
        agent.discrimination_success = agent.n_success_dg/agent.n_discrimination_games
    return answer
Example #3
0
 def load_initial_knowledge(self, dat):
     """ load of initial knowledge
     """
     for i in dat:
         cs_tag = auks.generateRandomTag(6)
         self.cs.create_pconcept(cs_tag, i[1])       # create pconcept in CS  
         self.cs_cs.create_node(cs_tag)              # create cs node in cs_cs
         self.cs_cs.add_link(cs_tag, cs_tag)         # add link between cs and cs node
         self.lex.add_word(i[0])                     # create word in lexicon
         self.lex_lex.create_node(i[0])              # create lex node in lex_lex
         self.lex_lex.add_link(i[0], i[0])           # add link between lex and lex node
         self.cs_lex.add_link(cs_tag, i[0])          # add link between lex and cs matrix