def run_guessing_game(thread, n_cycles, context_size):
""" runs a guessing game for a number of cycles
"""
count = 0
output = []
test_succes = []
while count < cfg.replicas:
gl.agent2 = agent.Agent("agent2", "learner")
if cfg.training_type == "c1": # rgb colour data
if cfg.training_data == 0:
training_data = auks.generate_training_data_colour(n_cycles, context_size)
gl.agent1 = agent.Agent("agent1", "teacher", ["l", data.colour_data])
elif cfg.training_data == 2:
training_data = auks.generate_training_data_colour_shape(n_cycles, context_size)
gl.agent1 = agent.Agent("agent1", "teacher", data.la_colour_shape)
elif cfg.training_data == 3:
training_data = auks.generate_training_data_artificial(n_cycles, context_size)
gl.agent1 = agent.Agent("agent1", "teacher", data.artificial_data2)
if cfg.training_type == "c2": # hsv colour data
training_data = auks.generate_training_data_colour(n_cycles, context_size, "hsv")
gl.agent1 = agent.Agent("agent1", "teacher", ["l", data.colour_data_hsv])
gl.cycle = 0
guessing_success = []
test_success = []
while gl.cycle < n_cycles:
guessing_game(gl.agent1, gl.agent2, training_data[gl.cycle], ran.randint(0, context_size-1))
if cfg.test_type == "direct":
gl.agent2.test_succes.append(test_knowledge(gl.agent1, gl.agent2, cfg.n_tests))
elif cfg.test_type =="language game":
gl.agent2.test_succes.append(gl.agent2.guessing_success)
gl.cycle += 1
# visuals
if cfg.show_in_panda:
if thread.stop:
break
thread.emit(SIGNAL("update()"))
time.sleep(0.02)
if gl.cycle % 100 == 0:
print gl.cycle
print "replica " + str(count+1) + " gg_success=" + str(gl.agent2.guessing_success)
test_succes.append(gl.agent2.test_succes)
count += 1
# name = "learning=" + str(cfg.associative_word_learning) + "_context=" + str(cfg.context_size) + "_replicas=" + str(cfg.replicas)+ "_cycle=" + str(cfg.n_cycles) + "_dist=" + str(cfg.sample_minimum_distance)
# inout.write_output("guessing_game_" + name, output)
# inout.write_output("test_success_" + name, success_output)
# inout.save_matrix(gl.agent2.agent_name, "cs_cs", gl.agent2.cs_cs.matrix)
# inout.save_matrix(gl.agent2.agent_name, "cs_lex", gl.agent2.cs_lex)
# inout.save_matrix(gl.agent2.agent_name, "lex_lex", gl.agent2.lex_lex.matrix)
inout.save_knowledge(gl.agent2)
inout.write_out("teaching=" + cfg.teaching_type + " test=" + cfg.test_type, [auks.calc_mean(test_succes)])
return [[auks.calc_mean(test_succes), "teaching=" + cfg.teaching_type + " test=" + cfg.test_type]]
def learn_colour(self, word3):
config.detect_colour = True
config.idle_go = False
time.sleep(0.1)
percept_data = self.camera.return_colour()
if percept_data:
#per_dat = [["c",[["h",percept_data[0]], ["s",percept_data[1]], ["v",percept_data[2]]]]]
per_dat = [["c",[["r",percept_data[0]], ["g",percept_data[1]], ["b",percept_data[2]]]]]
self.learning_agent.learn_concept(word3, per_dat)
print "\n learning " + word3
inout.save_knowledge(self.learning_agent)
else:
print "I didn't get it, please repeat"
def run_direct_instruction(thread):
""" runs direct instruction from teaching agent to learning agent for given number of cycles
"""
if cfg.teacher_type == "h":
run_human_teaching(cfg.n_cycles)
if cfg.teacher_type == "a":
count = 0
agent2_similarity = []
agent2_test_succes = []
while count < cfg.replicas:
training_data = []
if cfg.training_type == "a1":
#generate_artificial_knowledge(n_dom, av_dimensions, avn_exemplars, av_words, av_associations, av_cluster_size = None)
a_data = auks.generate_artificial_knowledge(1, 3, 10, 10, 3, 3)
gl.agent1 = agent.Agent("agent1", "teacher", ('a', a_data))
training_data = auks.generate_training_data_simple(cfg.n_cycles)
elif cfg.training_type == "a2":
a_data = auks.create_knowledge_with_a_data(data.artificial_percepts, data.artificial_san_percepts, data.artificial_words, data.artificial_san_words, data.artificial_matrix)
gl.agent1 = agent.Agent("agent1", "teacher", ('a', a_data))
training_data = auks.generate_training_data_simple(cfg.n_cycles)
elif cfg.training_type == "c1":
gl.agent1 = agent.Agent("agent1", "teacher", ('l', data.colour_data))
training_dat = auks.generate_training_data_colour(cfg.n_cycles, 1)
for i in training_dat:
training_data.append(i[0]) # remove one list level for compatibility
elif cfg.training_type == "c2":
gl.agent1 = agent.Agent("agent1", "teacher", ('l', data.colour_data_hsv))
training_dat = auks.generate_training_data_colour(cfg.n_cycles, 1)
for i in training_dat:
training_data.append(i[0]) # remove one list level for compatibility
inout.save_knowledge(gl.agent1)
gl.agent2 = agent.Agent("agent2", "learner")
agent2_numbers = [["words","percepts"]]
agent2_sim = []
for x, i in enumerate(training_data):
a1_word = gl.agent1.name_object(i)
gl.agent2.learn_concept(a1_word, i)
#learning
if cfg.associative_word_learning:
a1_word_related = gl.agent1.name_object_related(i)
#print a1_word, a1_word_related
gl.agent2.learn_word_association(a1_word, a1_word_related)
if cfg.associative_object_learning:
pass # to be implemented
agent2_numbers.append([gl.agent2.n_words, gl.agent2.n_percepts])
#testing
if cfg.test_type == "direct": # direct test
gl.agent2.test_succes.append(run_objects_test(gl.agent1, gl.agent2, cfg.n_tests))
elif cfg.test_type == "language game": # language game test
gl.agent2.test_succes.append(run_guessing_game_test(gl.agent1, gl.agent2, cfg.n_tests, cfg.context_size))
agent2_sim.append(calc_similarity_agents(gl.agent1, gl.agent2))
# visuals
if cfg.show_in_panda:
if thread.stop:
break
thread.emit(SIGNAL("update()"))
time.sleep(0.05)
if x % 10 == 0:
print x
count += 1
agent2_similarity.append(agent2_sim)
agent2_test_succes.append(gl.agent2.test_succes)
print "replica " + str(count)
# stats
inout.save_knowledge(gl.agent2)
inout.write_out("agent2_numbers", agent2_numbers)
inout.write_out("teaching=" + cfg.teaching_type + " test=" + cfg.test_type + " 2nd word=" + str(cfg.test_2nd_word), [auks.calc_mean(agent2_test_succes)])
#inout.write_out_average("agent2_test_correct_clusters=" + str(cfg.SAN_clusters) + "_domain=" + str(cfg.training_type) + "_alearning=" + str(cfg.associative_word_learning), agent2_correct)
#inout.write_out_average("agent2_similarity_clusters=" + str(cfg.SAN_clusters) + "_domain=" + str(cfg.training_type) + "_alearning=" + str(cfg.associative_word_learning), agent2_similarity)
#go.output([auks.calc_mean(agent2_correct)], "test success", "# interactions", "% correct", "agent2_test_succes")
#go.output([auks.calc_mean(agent2_comm_succes)], "communicative success", "# interactions", "% correct", "agent2_comm_succes")
return [[auks.calc_mean(agent2_test_succes), gl.test_title], [auks.calc_mean(agent2_similarity), "similarity"]]
