def to_prims(self): return { 'order': self.order, 'entity_iden': self.entity_iden, 'event_name': self.event_name, 'args': ser.serialize_embeddable(self.args), 'prevals': tuple(ser.serialize_embeddable(prev) for prev in self.prevals) }
def to_prims(self): return { 'train_bot': self.train_bot, 'adver_bot': self.adver_bot, 'bot_folder': self.bot_folder, 'train_seq': list(ser.serialize_embeddable(ses) for ses in self.train_seq), 'cur_ind': self.cur_ind }
def _run(args): settings: TrainSettings = None if not os.path.exists(args.settings): os.makedirs(os.path.dirname(args.settings), exist_ok=True) settings = TrainSettings.defaults(args.bot) with open(args.settings, 'w') as outfile: json.dump(ser.serialize_embeddable(settings), outfile) else: with open(args.settings, 'r') as infile: rawsettings = json.load(infile) settings = ser.deserialize_embeddable(rawsettings) os.makedirs(settings.bot_folder, exist_ok=True) executable = 'python3' if args.py3 else 'python' port = args.port create_flags = 0 if args.headless else subprocess.CREATE_NEW_CONSOLE nthreads = args.numthreads spec = not args.headless ncores = psutil.cpu_count(logical=False) if args.aggressive and nthreads > (ncores // 3): print(f'auto-reducing simultaneous servers to {ncores // 3} since there are {ncores} ' + 'cores and we need 3 cores per server') nthreads = ncores // 3 if os.path.exists(settings.replay_folder): rb.FileWritableReplayBuffer(settings.replay_folder, exist_ok=True).close() while settings.cur_ind < len(settings.train_seq): print('--starting session--') print(settings.current_session) _get_experiences_async(settings, executable, port, port + 10*nthreads, create_flags, args.aggressive, spec, nthreads) _train_experiences(settings, executable) if args.debug: break _cleanup_session(settings) settings.cur_ind += 1 with open(args.settings, 'w') as outfile: json.dump(ser.serialize_embeddable(settings), outfile) print('--finished--')
def to_prims(self): return { 'order': self.order, 'attacker_iden': self.attacker_iden, 'defender_iden': self.defender_iden, 'og_damage': self.og_damage, 'tags': tuple(self.tags), 'attack_prevals': tuple( ser.serialize_embeddable(prev) for prev in self.attack_prevals), 'defend_prevals': tuple( ser.serialize_embeddable(prev) for prev in self.defend_prevals), }
def _get_experiences_async(settings: TrainSettings, executable: str, port_min: int, port_max: int, create_flags: int, aggressive: bool, spec: bool, nthreads: int): num_ticks_to_do = settings.current_session.tar_ticks if os.path.exists(settings.replay_folder): replay = rb.FileReadableReplayBuffer(settings.replay_folder) num_ticks_to_do -= len(replay) replay.close() if num_ticks_to_do <= 0: print(f'get_experiences_async nothing to do (already at {settings.replay_folder})') return replay_paths = [os.path.join(settings.bot_folder, f'replay_{i}') for i in range(nthreads)] setting_paths = [os.path.join(settings.bot_folder, f'settings_{i}.json') for i in range(nthreads)] workers = [] serd_settings = ser.serialize_embeddable(settings) ports_per = (port_max - port_min) // nthreads if ports_per < 3: raise ValueError('not enough ports assigned ' + f'({nthreads} threads, {port_max-port_min} ports)') ticks_per = int(math.ceil(num_ticks_to_do / nthreads)) for worker in range(nthreads): proc = Process(target=_get_experiences_target, args=(serd_settings, executable, port_min + worker*ports_per, port_min + (worker+1)*ports_per, create_flags, aggressive, spec, replay_paths[worker], setting_paths[worker], ticks_per)) proc.start() workers.append(proc) time.sleep(1) for proc in workers: proc.join() print(f'get_experiences_async finished, storing in {settings.replay_folder}') if os.path.exists(settings.replay_folder): filetools.deldir(settings.replay_folder) if os.path.exists(settings.replay_folder): tmp_replay_folder = settings.replay_folder + '_tmp' os.rename(settings.replay_folder, tmp_replay_folder) replay_paths.append(tmp_replay_folder) if os.path.exists(HOLDOVER_DIR): replay_paths.append(HOLDOVER_DIR) rb.merge_buffers(replay_paths, settings.replay_folder) for path in replay_paths: filetools.deldir(path)
def to_prims(self): return { 'iden': self.iden, 'x': self.x, 'y': self.y, 'depth': self.depth, 'health': self.health, 'base_max_health': self.base_max_health, 'base_damage': self.base_damage, 'base_armor': self.base_armor, 'modifiers': [ser.serialize_embeddable(mod) for mod in self.modifiers], 'items': dict((str(key), ser.serialize_embeddable(val)) for key, val in self.items), }
def to_prims(self): return { 'attacker_iden': self.attacker_iden, 'attack_result': ser.serialize_embeddable(self.attack_result) }
def to_prims(self): return { 'order': self.order, 'depth': self.depth, 'dungeon': ser.serialize_embeddable(self.dungeon) }
def to_prims(self): return { 'order': self.order, 'entity_iden': self.entity_iden, 'modifier': ser.serialize_embeddable(self.modifier) }
def to_prims(self) -> typing.Any: return { 'order': self.order, 'entity': ser.serialize_embeddable(self.entity) }
def to_prims(self): return {'thing': ser.serialize_embeddable(self.thing)}
def to_prims(self): return {'dgen': ser.serialize_embeddable(self.dgen)}
def to_prims(self): return { 'dgen': ser.serialize_embeddable(self.dgen), 'p1_depth': self.p1_depth, 'p2_depth': self.p2_depth }
def to_prims(self): return { 'game_state': ser.serialize_embeddable(self.game_state), 'player_iden': self.player_iden }
def to_prims(self): return {'update': ser.serialize_embeddable(self.update)}