def lookup_attractors(bn: OpenBooleanNetwork):
ts = dict()
pt_input_configs = itertools.product(TRUTH_VALUES,
repeat=len(bn.input_nodes))
for i in pt_input_configs:
for n, v in zip(bn.input_nodes, i):
bn[n].state = v
actual_state = bn.update()
trajectory = []
while binstate(actual_state) not in set(trajectory):
trajectory.append(binstate(actual_state))
for n, v in zip(bn.input_nodes, i):
bn[n].state = v
actual_state = bn.update()
cutoff = trajectory.index(binstate(actual_state))
# pprint(trajectory[cutoff:])
ts.update({tuple(trajectory[cutoff:]): None})
return [*ts.keys()]
def test_bn_update(self):
bn = template_behaviour_generator(5, 2, 0.5, 0.0, 1, 0).new()
bn_copy = BooleanNetwork.from_json(bn.to_json())
matching_states = []
for _ in range(10):
s1 = binstate(bn.update())
s2 = binstate(bn_copy.update())
matching_states.append(s1 == s2)
self.assertTrue(all(matching_states))
def test_state_attraction(bn, state, inputs, phi) -> (str, str):
for j, node in enumerate(bn.nodes):
node.state = state[j]
attractors = get_attraction_basin(bn, phi=phi, bninput=inputs)
# Only one attractor shall appear for each input in absence of noise
return binstate(inputs), attractors[0][0] if len(attractors) == 1 else None
def __init__(self, selector: SelectiveBooleanNetwork,
behaviours: Dict[str, BNController],
bin_strategies: Dict[str, Callable[[dict, float], dict]],
bin_thresholds: Dict[str, float], noise_rho: float,
input_fixation_steps: int, sensing_interval: int):
self.__selector = selector
self.__behaviours = behaviours
self.__bin_strategies = bin_strategies
self.__bin_thresholds = bin_thresholds
self.__attractors = self.__selector.atm.dattractors
self.__curr_attr = None
self.__atm = self.__selector.atm.dtableau
self.__bmap = defaultdict(self.__default_behaviour_strategy,
[(binstate(s), k)
for k, attr in self.__attractors.items()
for s in attr])
print(self.__behaviours)
self.__signal = -1 # True #
for k in self.__selector.keys:
self.__selector[k].state = random.choice([True, False
]) # self.__signal #
self.__sensing_interval = sensing_interval
self.__noise_rho = noise_rho
self.__input_fixation_steps = input_fixation_steps
self.__next_sensing = 0
self.__input_fixed_for = 0
self.__light_data = []
for a1 in luts))
tts = OrderedDict()
for path in cpaths(GLOBALS.sim_data_path, recursive=1):
# print(path)
if path.is_file():
sim_data = read_json(path)
a = dict()
l = -1
for e in sim_data['data']:
l = len(a)
a.update({binstate(e['bnstate']): binstate(e['bnstate'])})
if len(a) == l:
if binstate(e['bnstate']) not in tts:
tts[binstate(e['bnstate'])] = tuple(a.keys())
a.clear()
l = -1
print('Test Trajectories:')
pprint([*tts.values()])
print(len(tts), end='\n\n')
print(sum(
any(set(a).intersection(set(tts[k])) for a in luts) for k in tts))
pass
def __call__(self, morphology: EPuckMorphology, step: int, timestep: int):
# BN update is faster than sensor sampling frequency
sensed = False
if self.__next_sensing == step:
sensed = True
self.__next_sensing += int(self.__sensing_interval / timestep)
# Collect light data
self.__light_data = dict(
(k, l.read()) for k, l in morphology.light_sensors.items())
# print(self.__light_data)
# Collect Radio messages
r = morphology.receivers[-1]
if r.device.getQueueLength() > 0:
pkt = int(r.device.getData(), 2)
self.__input_fixed_for = 0
self.__signal = pkt
while r.device.getQueueLength() > 0:
r.device.nextPacket()
print(f"Env. signal {pkt} received.")
if self.__signal != -1:
if self.__input_fixed_for < self.__input_fixation_steps:
# print('F')
for l in self.__selector.input_nodes:
self.__selector[l].state = self.__signal
# print(l, self.__selector[l].state)
self.__input_fixed_for += 1
pass
else:
# Apply random noise
# print('Noise')
# Apply Binarization Strategies
bin_light_data = self.__bin_strategies[DeviceName.LIGHT](
self.__light_data, self.__bin_thresholds[DeviceName.LIGHT])
noise_rho = sum(bin_light_data.values()) / len(bin_light_data)
noise_rho = max(self.__noise_rho, noise_rho)
k = random.randint(1, max(1, sum(bin_light_data.values())))
nodes = random.choices(self.__selector.keys, k=k)
for n in nodes:
apply_noise = random.choices(TRUTH_VALUES,
[noise_rho, 1.0 - noise_rho])[0]
if apply_noise:
self.__selector[n].state = not self.__selector[n].state
pass
# Update network state
bn_state = self.__selector.update()
self.__curr_attr = self.__bmap[binstate(bn_state)]
# print(self.__selector.attractors_input_map)
# print(self.__curr_attr)
cdata = self.__behaviours[self.__curr_attr](morphology, step, timestep,
sensed)
cdata.noise = self.__signal == -1
cdata.attr = self.__curr_attr
cdata.input = self.__signal
return cdata