def evaluate_pt_bncontroller(simconfig: Config, bn: OpenBooleanNetwork, on: tuple):
'''
Evaluate the given BN model as a robot controller on the given set of points/parameters.
Returns:
* function score
* final distance
* light initial position
* agent initial position
* agent y-axis rotation
'''
lpos, apos, yrot, *_ = on
simconfig.sim_agent_position = apos
simconfig.sim_light_position = lpos
simconfig.sim_agent_yrot_rad = yrot
stub_utils.run_simulation(simconfig, bn)
data = read_json(simconfig.sim_data_path)
score, dist = simconfig.eval_aggr_function(data, lpos)
logger.info(
'iDistance: (m)', lpos.dist(apos), '|',
'yRot: (deg)', (yrot / math.pi * 180), '|',
'fDistance: (m)', dist, '|',
'score: (m2/W)', score, '|',
)
return score, dist, lpos, apos, yrot
def collect_bn_models(
paths: Iterable or Path,
bn_deserializer=find_bn_type,
ffilter=lambda x: x.is_file() and re.search(MODEL_NAME_PATTERN, x.name)):
files = dict()
bns = defaultdict(list)
for path in futils.cpaths(paths, recursive=3):
# print(path.is_file(), re.search(MODEL_NAME_PATTERN, path.name))
if path.is_dir():
f, bn, *_ = collect_bn_models(path.iterdir(),
bn_deserializer=bn_deserializer,
ffilter=ffilter)
bns.update(**bn)
files.update(**f)
elif ffilter(path):
# print(path)
name = path.with_suffix('').name
bns[name] = bn_deserializer(read_json(path))
files[name] = path
return files, bns
def test_selector_constraint_4(self):
bn = SelectiveBooleanNetwork.from_json(
read_json('./test/bn_for_test.json'))
c = constraints.test_attraction_basins(bn, 10)
self.assertTrue(c)
def test_selector_constraint_2(self):
bn = SelectiveBooleanNetwork.from_json(
read_json('./test/bn_for_test.json'))
self.assertTrue(
constraints.test_attractors_transitions(bn, {
'a0': {
'a0': 0.3,
'a1': 0.3
},
'a1': {
'a0': 0.3,
'a1': 0.3
},
}))
def generate_or_load_bn(params: BNParams, path: Path, save_virgin=False):
__bn = None
if check_path(path, create_if_dir=True):
generator = template_behaviour_generator(*params)
__bn = generate_rbn(generator.new_obn, force_consistency=True)
if save_virgin:
p = path / 'virgin_bn_{date}.json'.format(date=FROZEN_DATE)
write_json(__bn.to_json(), p)
logger.info(f'Virgin BN saved to {p}.')
else:
__bn = OpenBooleanNetwork.from_json(read_json(path))
logger.info(f'BN loaded from {path}.')
return __bn
ts.update({tuple(trajectory[cutoff:]): None})
return [*ts.keys()]
###############################################################################
if __name__ == "__main__":
load_global_config()
ps = cpaths(GLOBALS.bn_model_path, recursive=3) + cpaths(
list(map(Path, GLOBALS.slct_behaviours_map.values())))
for path in ps:
bn = OpenBooleanNetwork.from_json(read_json(path))
luts = lookup_attractors(bn)
print('BN attractors:')
pprint(bn.atm.mapped_attractors(binstate))
print(len(bn.atm.attractors), end='\n\n')
print('Simulated Attractors:')
pprint(luts)
print(len(luts), end='\n\n')
print(
sum(
any(
set(a1).intersection(set(a2))
for a2 in bn.atm.mapped_attractors(binstate))
for a1 in luts))
def get_data(f: Path, pattern: str, uniqueness=3, parts=['%s', '%s', '%s']):
return (get_simple_fname(f.name,
pattern,
uniqueness=uniqueness,
parts=parts), DataFrame.from_dict(read_json(f)))
if __name__ == "__main__":
load_global_config()
NP = cpu_count()
pool = Pool(processes=NP)
mapper = lambda f, p: pool.imap_unordered(f, p, chunksize=2 * NP)
for path in cpaths(GLOBALS.bn_model_path, recursive=3):
print(path)
bnjson = read_json(path)
bn = SelectiveBooleanNetwork.from_json(bnjson)
# print(2**len(bn))
# print(bnjson['gen_params'])
i = max(map(len, bn.atm.attractors)) * len(bn) * 20
t = time.perf_counter()
if isinstance(GLOBALS.slct_target_transition_tau, list):
tTau_map = {
'a0': {
'a1': max(GLOBALS.slct_target_transition_tau)
},
'a1': {
def c2no1(bnname, c):
# bnname, c = cols
print(bnname)
bn = BooleanNetwork.from_json(
read_json(GLOBALS.bn_model_path / 'stats/models' / bnname))
return c if len(bn.atm.attractors) > 1 else False
from pathlib import Path
from pandas import DataFrame
from pprint import pprint
from bncontroller.sim.utils import GLOBALS, load_global_config
from bncontroller.boolnet.selector import SelectiveBooleanNetwork
from bncontroller.boolnet.structures import BooleanNetwork
from bncontroller.jsonlib.utils import read_json
from bncontroller.filelib.utils import get_dir
if __name__ == "__main__":
load_global_config()
for path in get_dir(GLOBALS.bn_model_path).iterdir():
if path.is_file():
bn: BooleanNetwork = BooleanNetwork.from_json(read_json(path))
print(str(path))
print(DataFrame(bn.atm.dtableau).T)
print(bn.atm.tableau)
for k, a in bn.atm.dattractors.items():
print(k, a)
print(bn.atm.attractors)
def test_selector_constraint_1(self):
bn = SelectiveBooleanNetwork.from_json(
read_json('./test/bn_for_test.json'))
self.assertTrue(constraints.test_attractors_number(bn, 2))
self.assertFalse(constraints.test_attractors_number(bn, 4))
'apt_fapos': apt_fapos,
'apt_fdist': apt_fdist,
'apt_fyrot': apt_fyrot,
})
############################################################################
def weighted_pt(s, i, f):
return s * f / i
def weighted_apt(s, i, f):
return s * f / i
#############################################################################
if __name__ == "__main__":
from bncontroller.jsonlib.utils import read_json
data = read_json(
'D:\\Xander\\Documenti\\Projects\\BoolNetController\\res\\data\\sim\\handcheck_sim_data_20190730T145525281.json'
)
print(sbnc(data, Point3D.from_json({"x": 0.0, "y": 0.3, "z": -0.0})))
from bncontroller.boolnet.structures import OpenBooleanNetwork
from bncontroller.jsonlib.utils import read_json
#-------------------------------------------
load_global_config()
print(str(GLOBALS.bn_model_path))
logger = lambda *items: None
if not GLOBALS.sim_suppress_logging:
logger = FileLogger('BoolNetControl', path=GLOBALS.sim_log_path)
logger.suppress(GLOBALS.sim_suppress_logging)
bn = OpenBooleanNetwork.from_json(read_json(GLOBALS.bn_model_path), )
#-------------------------------------------
phototaxist = BNController(model=bn,
sensing_interval=GLOBALS.sim_sensing_interval_ms,
bin_thresholds=GLOBALS.sim_sensors_thresholds,
bin_strategies={
DeviceName.LIGHT: bin_strategies.phototaxis,
})
epuck = EPuck(GLOBALS.sim_run_time_s, GLOBALS.sim_timestep_ms,
GLOBALS.sim_event_timer_s)
epuck.position = GLOBALS.sim_agent_position
epuck.orientation = GLOBALS.sim_agent_yrot_rad
from bncontroller.jsonlib.utils import read_json, write_json
from bncontroller.sim.utils import GLOBALS, load_global_config
from bncontroller.boolnet.structures import OpenBooleanNetwork
from bncontroller.rtest import find_bn_type
if __name__ == "__main__":
load_global_config()
if isinstance(GLOBALS.bn_model_path,
list) or GLOBALS.bn_model_path.is_dir():
raise Exception('Model path should be a file.')
GLOBALS.app['mode'] = 'handcheck'
bn = find_bn_type(read_json(GLOBALS.bn_model_path))
config = GLOBALS.generate_sim_config()
### Generate simulation world file for training ################################
stub_utils.generate_webots_worldfile(GLOBALS.webots_world_path,
config.webots_world_path,
config.arena_params)
stub_utils.generate_webots_props_file(GLOBALS.webots_world_path,
config.webots_world_path)
try:
proc_closure = stub_utils.run_simulation(config, bn)
except Exception:
pass
right=0.99,
bottom=0.1,
top=0.99,
wspace=0.0,
hspace=0.0)
plotter.legend(frameon=False, loc='upper right')
plotter.show()
################################################################
if __name__ == "__main__":
load_global_config()
for path in cpaths(GLOBALS.bn_model_path):
bn = find_bn_type(read_json(path))
i = []
o = []
if isinstance(bn, OpenBooleanNetwork):
i = bn.input_nodes
o = bn.output_nodes
plot_booleannetwork(
get_simple_fname(
path.with_suffix('').name, FNAME_PATTERN, ['%s', '%s', '%s']),
bn, i, o)
from bncontroller.sim.robot.core import BNController, SBNController
from bncontroller.sim.logging.logger import FileLogger
from bncontroller.sim.logging.datadumper import SimulationDataDumper
#-------------------------------------------
load_global_config()
# print(os.getcwd())
# print(GLOBALS.slct_behaviours_map)
logger = lambda *items: None
#-------------------------------------------
bnselector = SelectiveBooleanNetwork.from_json(read_json(
GLOBALS.bn_model_path))
bn_pt = OpenBooleanNetwork.from_json(
read_json(GLOBALS.slct_behaviours_map['0']), )
bn_apt = OpenBooleanNetwork.from_json(
read_json(GLOBALS.slct_behaviours_map['1']), )
phototaxist = BNController(
model=bn_pt,
sensing_interval=int(GLOBALS.sim_sensing_interval_ms),
bin_thresholds=dict(**GLOBALS.sim_sensors_thresholds),
bin_strategies={
DeviceName.LIGHT: bin_strategies.phototaxis,
},
led_color=0x00ff00)
args = parse_args(parser=parser, config_converter=Config.from_file)
data = OrderedDict(
**pu.collect_data(cpaths(args.config.test_data_path),
fpattern=r'rtest_data_(?:bn_subopt_)?' +
f'{fu.FNAME_PATTERN}.json',
recursively=args.recursively,
ds_merge_level=args.merge_level,
data_getter=get_data))
bninfos = OrderedDict()
for path in cpaths(args.config.bn_model_path, recursive=3):
if path.is_file() and 'json' in path.suffix and 'bn' in path.name:
jsonrepr = read_json(path)
try:
bn = SelectiveBooleanNetwork.from_json(jsonrepr)
info = jsonrepr['gen_params']
info['atm'] = bn.atm.tableau
info['ai_map'] = bn.attractors_input_map
info['a_len'] = dict(
map(lambda a: (a[0], len(a[1])),
bn.atm.dattractors.items()))
name = pu.get_simple_fname(path.name,
fu.FNAME_PATTERN,
parts=['%s', '%s', '%s'],
def test_selector_constraint_3(self):
bn = SelectiveBooleanNetwork.from_json(
read_json('./test/bn_for_test.json'))
i = max(map(len, bn.atm.attractors)) * len(bn) * 20
self.assertTrue(constraints.test_bn_state_space_homogeneity(
bn, i, 0.1))
def from_file(fp: Path or str):
return Config(**read_json(fp))
print(path)
data = dict()
for p in path.iterdir():
if p.name.startswith('dataframe') and 'json' in p.suffix:
m = regx.search(fn_pattern, p.name)
if m is not None:
# print(p)
d = dict((k, int(float(v))) for k, v in m.groupdict().items())
data.update({
p.name: {
'params': d,
'frame': DataFrame.from_dict(read_json(p))
}
})
#################################################################################
def AND(s: Series):
return all(s.tolist())
def c2no1(bnname, c):
# bnname, c = cols
print(bnname)
bn = BooleanNetwork.from_json(
read_json(GLOBALS.bn_model_path / 'stats/models' / bnname))
return c if len(bn.atm.attractors) > 1 else False