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