def erase_all_knowledge(self):
# snb
self.snb = SensoryNeuralBlock()
self.snb.save("persistent_memory/sight_snb.p", "persistent_memory/hearing_snb.p")
# Relational Neural Block
self.rnb = RelNetwork(100)
RelNetwork.serialize(self.rnb, "persistent_memory/rnb.p")
# Addition by memory network
self.am_net = CulturalNetwork(100)
CulturalNetwork.serialize(self.am_net, "persistent_memory/am_net.p")
# Syllables net
self.syllables_net = CulturalNetwork(100)
CulturalNetwork.serialize(self.syllables_net, "persistent_memory/syllables_net.p")
# Words net
self.words_net = CulturalNetwork(100)
CulturalNetwork.serialize(self.words_net, "persistent_memory/words_net.p")
# Sight-Syllables rel network
self.ss_rnb = RelNetwork(100)
RelNetwork.serialize(self.ss_rnb, "persistent_memory/ss_rnb.p")
# Geometric Neural Block
self.gnb = GeometricNeuralBlock()
GeometricNeuralBlock.serialize(self.gnb, "persistent_memory/gnb.p")
################ INTENTIONS ####################################################################################
self.episodic_memory = EpisodicMemoriesBlock()
EpisodicMemoriesBlock.serialize(self.episodic_memory, "persistent_memory/episodic_memory.p")
self.decisions_block = DecisionsBlock()
DecisionsBlock.serialize(self.decisions_block, "persistent_memory/decisions_block.p")
self.internal_state = InternalState()
InternalState.serialize(self.internal_state, "persistent_memory/internal_state.p")
self.desired_state = InternalState([0.5,1,1])
InternalState.serialize(self.desired_state, "persistent_memory/desired_state.p")
def __init__(self):
# Desired state
self.desired_state = InternalState()
self.desired_state.set_state([0.5,1,1])
# Initial internal state
self.internal_state = InternalState([0.5,0.5,0.5])
# Decision by prediction network
self.decision_prediction_block = DecisionByPredictionBlock()
self.decision_prediction_block.set_desired_state(self.desired_state)
self.decision_prediction_block.set_internal_state(self.internal_state)
# DEFAULT TRAINING, IT CAN LATER BE OVERRIDEN
# Create a random training set so that the net can learn the relation prediction = (ei + choice.bcf)/2
# We require a minimum of 18 points
training_set = []
for index in range(20):
ei = [random.random(), random.random(), random.random()]
choice_bcf = [random.random(), random.random(), random.random()]
prediction = [ei_j / 2.0 + choice_bcf_j / 2.0 for ei_j, choice_bcf_j in zip(ei, choice_bcf)]
training_set.append((ei + choice_bcf, prediction))
# Remodel predictive net
self.decision_prediction_block.remodel_predictive_net(training_set)
self._inputs = None
self._new_inputs = False
self.decision = None
self._last_decision_type = None
self._last_selected_input = None
self._last_decision_internal_state = None
def __init__(self):
# Desired state
self.desired_state = InternalState()
self.desired_state.set_state([0.5,1,1])
# Initial internal state
self.internal_state = InternalState([0.5,0.5,0.5])
# Decision by prediction network
self.decision_prediction_block = DecisionByPredictionBlock()
self.decision_prediction_block.set_desired_state(self.desired_state)
self.decision_prediction_block.set_internal_state(self.internal_state)
# DEFAULT TRAINING, IT CAN LATER BE OVERRIDEN
# Create a random training set so that the net can learn the relation prediction = (ei + choice.bcf)/2
# We require a minimum of 18 points
training_set = []
# 3.2.4.1 todo: parallelize
# Helper method, used to execute in parallel
def __generate_training(index):
ei = [random.random(), random.random(), random.random()]
choice_bcf = [random.random(), random.random(), random.random()]
prediction = [ei_j / 2.0 + choice_bcf_j / 2.0 for ei_j, choice_bcf_j in zip(ei, choice_bcf)]
return ei + choice_bcf, prediction
# Init thread's pool, with the determined processor number
pool = Pool(DetectSystem().cpu_count())
# Parallel execution
training_set = pool.map(__generate_training, range(20))
# for index in range(20):
# ei = [random.random(), random.random(), random.random()]
# choice_bcf = [random.random(), random.random(), random.random()]
# prediction = [ei_j / 2.0 + choice_bcf_j / 2.0 for ei_j, choice_bcf_j in zip(ei, choice_bcf)]
# training_set.append((ei + choice_bcf, prediction))
# Remodel predictive net
self.decision_prediction_block.remodel_predictive_net(training_set)
self._inputs = None
self._new_inputs = False
self.decision = None
self._last_decision_type = None
self._last_selected_input = None
self._last_decision_internal_state = None
def __init__(self):
self.output = []
self.shift_register1 = Lfsr(input("seed for the first RFSR:"),[8,12,20,25])
self.shift_register2 = Lfsr(input("seed for the second RFSR:"),[21,16,24,31])
self.shift_register3 = Lfsr(input("seed for the third RFSR:"),[4,24,28,33])
self.shift_register4 = Lfsr(input("seed for the fourth RFSR:"),[4,28,36,39])
self.r1 = Register(input("seed for the register R1:"))
self.r2 = Register(self.r1.output)
self.t1 = InternalState()
self.t2 = InternalState()
self.adder1 = Adder()
self.adder2 = Adder()
self.iz = Iz()
self.xor_iz_t2 = Xor([self.t2.output,self.iz.output])
self.xor_t1_xor = Xor([self.t1.output,self.xor_iz_t2.output])
self.xor_zt = Xor([self.shift_register1.output,self.shift_register2.output,
self.shift_register3.output,self.shift_register4.output,self.r1.least_significant()])
def main():
my_state = InternalState()
init()
logging.info('start service ...')
try:
while (my_state.state is not STATE_MASTER):
client = Client()
my_state = client.run(4, my_state)
master = Master()
master.run(my_state)
except KeyboardInterrupt:
sys.exit()
def create_kernel(self):
# snb
self.snb = SensoryNeuralBlock("no_data", "no_data", self.project_id)
self.snb.save("snb_s", "snb_h", self.project_id, self.brain)
# Relational Neural Block
self.rnb = RelNetwork(100)
RelNetwork.serialize(self.rnb, "rnb", self.project_id)
# Addition by memory network
self.am_net = CulturalNetwork(100)
CulturalNetwork.serialize(self.am_net, "am_net", self.project_id)
# Syllables net
self.syllables_net = CulturalNetwork(100)
CulturalNetwork.serialize(self.syllables_net, "syllables_net",
self.project_id)
# Words net
self.words_net = CulturalNetwork(100)
CulturalNetwork.serialize(self.words_net, "words_net", self.project_id)
# Sight-Syllables rel network
self.ss_rnb = RelNetwork(100)
RelNetwork.serialize(self.ss_rnb, "ss_rnb", self.project_id)
# Geometric Neural Block
self.gnb = GeometricNeuralBlock()
GeometricNeuralBlock.serialize(self.gnb, "gnb", self.project_id)
################ INTENTIONS ####################################################################################
self.episodic_memory = EpisodicMemoriesBlock()
EpisodicMemoriesBlock.serialize(self.episodic_memory,
"episodic_memory", self.project_id)
self.decisions_block = DecisionsBlock()
DecisionsBlock.serialize(self.decisions_block, "decisions_block",
self.project_id)
self.internal_state = InternalState()
InternalState.serialize(self.internal_state, "internal_state",
self.project_id)
self.desired_state = InternalState([0.75, 0.75, 0.75])
InternalState.serialize(self.desired_state, "desired_state",
self.project_id)
def learn(self):
# CORREGIR PARA QUE FUNCIONE CUANDO EL PATRON DEL HEARING NO SE APRENDE SINO QUE YA SE CONOCE
self.snb.learn(self.h_knowledge_in, self.s_knowledge_in.get_pattern())
learned_ids = self.snb.get_last_learned_ids()
rel_knowledge = RelKnowledge(learned_ids[0], learned_ids[1])
self.rnb.learn(rel_knowledge)
RelNetwork.serialize(self.rnb, "persistent_memory/rnb.p")
self.snb.save("persistent_memory/sight_snb.p", "persistent_memory/hearing_snb.p")
################ INTENTIONS ####################################################################################
# New learned item will produce changes in internal state
self.feed_internal_state(self._internal_state_in)
# New learned item and passed internal state should be related as an episode
internal_state_in = InternalState(self._internal_state_in)
self.episodic_memory.bum()
self.episodic_memory.check(learned_ids[1])
self.episodic_memory.clack(internal_state_in)
EpisodicMemoriesBlock.serialize(self.episodic_memory, "persistent_memory/episodic_memory.p")
# Memories
MEMORIES_COUNT = 6
memories = [CulturalGroup() for i in range(MEMORIES_COUNT)]
import random
bcf = []
for i in range(MEMORIES_COUNT):
memories[i].bum()
memories[i].learn(i)
bcf.append(BiologyCultureFeelings())
new_state = [random.random(), random.random(), random.random()]
bcf[i].set_state(new_state)
memories[i].clack(bcf[i])
print("Memory ", i, " bcf is",
memories[i].get_tail_knowledge().get_state())
d_block = DecisionsBlock()
internal_state = InternalState()
internal_state.set_state([0.5, 1, 1])
d_block.set_internal_state(internal_state)
desired_state = InternalState()
desired_state.set_state([0.5, 1, 1])
d_block.set_desired_state(desired_state)
d_block.set_input_memories(memories)
output = d_block.get_output_memory()
print("Decisions Block output is ",
output.get_tail_knowledge().get_state())
print("made by ", d_block.conscious_block.get_last_decision_type())
print("Unconscious decisions ")
for mem in d_block.unconscious_output:
print(mem.get_tail_knowledge().get_state())
# BIOLOGY ALARMS
cdb.internal_state.set_state([0.9,1,1])
cdb.set_inputs(inputs)
print('-' * 60)
print 'BIOLOGY ALARM'
print 'Internal state: ', cdb.internal_state.get_state()
print 'Decision is: ', cdb.get_decision(), ' made by ', cdb.get_last_decision_type()
cdb.internal_state.set_state([0.1, 1, 1])
cdb.set_inputs(inputs)
print 'Internal state: ', cdb.internal_state.get_state()
print 'Decision is: ', cdb.get_decision(), ' made by ', cdb.get_last_decision_type()
# FEEDBACK TEST
test = True
internal_state = InternalState()
cdb.internal_state.set_state([0.5, 1, 1])
while test:
print 'FEEDBACK TEST'
print('-'*60)
i0.set_state(input('Enter input #0 ([B,C,F]): '))
i1.set_state(input('Enter input #1 ([B,C,F]): '))
i2.set_state(input('Enter input #2 ([B,C,F]): '))
cdb.set_inputs([i0, i1, i2])
print "Internal state: ", cdb.internal_state.get_state()
print "Decision: ", cdb.get_decision(), " made by ", cdb.get_last_decision_type()
internal_state.set_state(input('Feedback new internal state ([B,C,F]): '))
cdb.feedback(internal_state)
cdb.set_inputs([i0, i1, i2])
print "New decision would be: ", cdb.get_decision(), " made by ", cdb.get_last_decision_type()
test = input("Continue testing? (True/False): " )
for outcome_j, desired_j in zip(outcome,
self.desired_state.get_state()):
distance += abs(desired_j - outcome_j)
self.distances.append(distance)
return self.distances.index(min(self.distances))
## @}
#
# Tests
if __name__ == '__main__':
import random
desired_state = InternalState()
desired_state.set_state([0.5, 1, 1])
internal_state = InternalState([0.5, 0.5, 0.5])
decision_prediction = DecisionByPredictionBlock()
decision_prediction.set_desired_state(desired_state)
# Create a random training set so that the net can learn the relation prediction = (ei + choice.bcf)/2
# We require a minimum of 18 points
training_set = []
for index in range(10):
ei = [random.random(), random.random(), random.random()]
choice_bcf = [random.random(), random.random(), random.random()]
prediction = [
ei_j / 2.0 + choice_bcf_j / 2.0
for ei_j, choice_bcf_j in zip(ei, choice_bcf)