def main(): board_size = 4 max_num_moves = int(board_size ** 2) state_space_size = int(board_size ** 2 + 1) conv_layers = [] state_space_size = 128 hidden_layers = [state_space_size, max_num_moves] la = 0.01 state_manager = StateManager(board_size) num_simulations = 200 player1 = NeuralActor(conv_layers, hidden_layers, max_num_moves, la, 'sgd') player2 = NeuralActor(conv_layers, hidden_layers, max_num_moves, la, 'sgd') mct1 = MCT(player1, num_simulations) mct2 = MCT(player2, num_simulations) train = False if train == True: start_time = time.time() for i in range(0, 100): mct1.play_game(copy.deepcopy(state_manager)) training_data = mct1.get_training_data() loss = player1.update_Q(training_data) print(str(i) + " " + str(loss)) player1.store_model('data/16.3') else: player1.load_model('data/16.3') player2.load_model('data/16.3') win1 = 0 win2 = 0 for i in range(0, 1000): state_manager = StateManager(board_size) while not state_manager.player1_won() and not state_manager.player2_won(): if not state_manager.player1_to_move: move_index = random.randrange(0, board_size ** 2) while not StateManager.is_legal(move_index, state_manager.string_representation()): move_index = random.randrange(0, board_size ** 2) move = state_manager.convert_to_move(move_index) move = state_manager.convert_to_move(player2.get_action(state_manager.string_representation())) else: move_index = random.randrange(0, board_size ** 2) while not StateManager.is_legal(move_index, state_manager.string_representation()): move_index = random.randrange(0, board_size ** 2) move = state_manager.convert_to_move(move_index) #move = state_manager.convert_to_move(player2.get_action(state_manager.string_representation())) state_manager.make_move(move) #state_manager.show() if state_manager.player1_won(): win1 += 1 elif state_manager.player2_won(): win2 += 1 else: print("No winner") print("Times player 1 won: " + str(win1) + ". " + "Times player2 won: " + str(win2))
def play_series(self, agt1, agt2): player1_wins = 0 for i in range(self.G): print("[{}>{}]".format("-" * i, "." * (self.G - i - 1)), end="\r") sm = StateManager(5) while not sm.is_finished(): player = sm.game.get_current_player() state = np.array( [np.concatenate((player, sm.game.board), axis=None)]) if player == 1: predictions = agt1.predict(state)[0] else: predictions = agt2.predict(state)[0] legal_moves = sm.get_legal_moves() if len(sm.game.executedMoves) <= 1: best_move = random.choice(legal_moves) else: best_move = self.choose_best_move(predictions, legal_moves) sm.execute_move(best_move) if sm.get_winner() == 1: player1_wins += 1 print("{} won {}/{} against {}.".format(agt1.name, player1_wins, self.G, agt2.name)) print(np.reshape(sm.game.board, (boardsize, boardsize))) print(sm.game.executedMoves) return player1_wins
def main(): # initialize tk window for embedding pygame root = tk.Tk() embed = tk.Frame(root, width=WINDOW_WIDTH, height=WINDOW_HEIGHT) embed.pack(side=tk.LEFT) os.environ['SDL_WINDOWID'] = str(embed.winfo_id()) root.update() # initialize pygame pygame.init() # These are the only events we care about handling pygame.event.set_allowed([KEYUP, KEYDOWN, MOUSEBUTTONDOWN, ACTIVEEVENT]) pygame.mouse.set_visible(True) manager = StateManager(root) root.protocol("WM_DELETE_WINDOW", manager.ask_quit) # Main game loop # We put root.update() in here so that pygame.display.update() # doesn't interrupt tkinter's event handling while not manager.quit: t = time.clock() manager.update() manager.draw() pygame.display.update() root.update() dt = 1000 * (time.clock() - t) REAL_FPS = round(1000.0 / dt) root.title(f"FPS: {min(REAL_FPS, FPS)}/{FPS}") # The FPS is actually slightly more. This shouldn't matter. root.after(max(1, round(FRAME_TIME - dt) - 1)) manager.terminate()
def main(): config = Config() config_dict = config.get_config() board_size = config_dict['board_size'] episodes = config_dict['episodes'] num_simulations = config_dict['simulations'] la = config_dict['la'] optimizer = config_dict['optimizer'] M = config_dict['M'] G = config_dict['G'] conv_layer_filters = config_dict['conv_layer_filters'] conv_layer_kernels = config_dict['conv_layer_kernels'] max_num_moves = int(board_size**2) state_space_size = int(board_size**2 + 1) conv_layers = (conv_layer_filters, conv_layer_kernels) state_space_size = 128 hidden_layers = [state_space_size, max_num_moves] state_manager = StateManager(board_size) player = NeuralActor(conv_layers, hidden_layers, max_num_moves, la, optimizer) mct = MCT(player, num_simulations) # Train progressive policies for i in range(episodes): mct.play_game(copy.deepcopy(state_manager)) training_data = mct.get_training_data() loss = player.update_Q(training_data) print(str(i) + " " + str(loss)) if i % (episodes // (M - 1)) == 0: player.store_model('models/iteration' + str(i)) player.store_model('models/iteration' + str(episodes))
def run_multiple(): epochs = [10, 50] for e in epochs: config.epochs = e print(config.epochs) player = StateManager() player.play_game()
def play_with_agents(self, agt1, agt2): player_turn = 1 player1_wins = 0 for i in range(self.G): print("[{}>{}]".format("-" * i, "." * (self.G - i - 1)), end="\r") sm = StateManager(5) agent = MCTS(exploration_rate=1, anet=agt1) game = sm.create_game() tree = Tree(game, chanceOfRandom=0.0) state = tree.root while not sm.is_finished(): if player_turn == 1: agent.anet = agt1 best_child = agent.uct_search(tree, state, num_search_games) else: agent.anet = agt2 best_child = agent.uct_search(tree, state, num_search_games) game.execute_move(best_child.move) state = best_child if sm.get_winner() == 1: player1_wins += 1 print("{} won {}/{} against {}.".format(agt1.name, player1_wins, self.G, agt2.name)) print(np.reshape(sm.game.board, (boardsize, boardsize)))
def main(): num_simulations = 20 max_depth = 5 mct1 = MCT(None, num_simulations, max_depth) state_manager = StateManager(4) for i in range(0, 1): mct1.play_game(copy.deepcopy(state_manager))
def _init_state(self, opt): self.state = StateManager( opt.experiment_class, opt.model_name, self.device, opt.model_type, opt.model_num_layers, opt.model_num_layers_vgg, opt.train_weights_init, opt.train_learning_rate, opt.train_weight_decay, opt.train_scheduler_step_size) if opt.model_load is not None: self.state.load(opt.model_load, opt.model_disable_lr_loading)
def vmc_login(sessionId, info): global g_id_state_manager g_id_state_manager[sessionId] = StateManager() g_id_state_manager[sessionId].vmc_util = VMCUtil() g_id_state_manager[sessionId].vmc_util.set_info(info) g_id_state_manager[sessionId].vmc_util.login() print("vmc_login: Logged in successfully")
def _init_state(self, opt): self.state = StateManager( opt.experiment_class, opt.model_name, self.device, opt.model_split_pos, opt.model_num_layers, opt.train_depth_grad_scale, opt.train_segmentation_grad_scale, opt.train_weights_init, opt.model_depth_resolutions, opt.model_num_layers_pose, opt.train_learning_rate, opt.train_weight_decay, opt.train_scheduler_step_size) if opt.model_load is not None: self.state.load(opt.model_load, opt.model_disable_lr_loading)
def expand(self): size = int((len(self.state) - 1)**0.5) state_manager = StateManager(size, self.state) possible_moves = state_manager.get_moves() self.children = [] for move in possible_moves: state_manager.make_move(move) self.children.append((Node(self, state_manager.string_representation()), 0)) # Visited 0 times state_manager.undo_move(move)
def __init__(self, feature_name, entity_field, sum_value_field, incl_count, incl_sum, incl_mean, decay_rate): """Instance initiated with state_id and sample_decay_rate""" self.feature_name = feature_name self.entity_field = entity_field self.sum_value_field = sum_value_field self.incl_count = incl_count self.incl_sum = incl_sum self.incl_mean = incl_mean self.decay_rate = decay_rate self.state_manager = StateManager()
def execute(self): self.state_manager = StateManager((REMOTE_HOST, STATE_MANAGER_PORT)) self.hardware_monitor = HardwareMonitor() self.transfer_manager = TransferManager( "HTTP://%s:%s/" % (REMOTE_HOST, TRANSFER_MANAGER_PORT), self.job_queue, self.completed_queue) self.adaptor = Adaptor(self.state_manager, self.hardware_monitor, self.transfer_manager, TRANSFER_POLICY) self._bootstrap() self._process() self._aggregate() self.tock = time.time() logging.info("Run time: %d" % (self.tock - self.tick))
def __init__(self, master = None, pathToImage = None, name=None, image=None): super().__init__(master = master) if pathToImage is not None and image is None: self.pathToImage = pathToImage self.image = ImageSaved(pathToImage) elif image is not None: self.image = image self.manager = StateManager(self.image.cv2Image) self.set_images() self.set_geometry() self.set_basic(master, name) self.place_menu() self.manage_line_profile() self.bind_functions()
def rollout(self, leaf): size = int((len(leaf.state) - 1) ** 0.5) leaf_state, first_iteration = StateManager(size, leaf.state), True while True: if leaf_state.player1_won(): score = 1.0 return score elif leaf_state.player2_won(): score = -1.0 return score if leaf_state.is_finished(): print("No winner error") quit() if first_iteration: possible_moves = leaf_state.get_moves() move = possible_moves[random.randint(0, len(possible_moves) - 1)] first_iteration = False else: move = leaf_state.convert_to_move(self.nn.get_action(leaf_state.string_representation())) leaf_state.make_move(move)
def run(self): self.state_manager = StateManager((LOCAL_HOST, STATE_MANAGER_PORT)) self.hardware_monitor = HardwareMonitor() self.transfer_manager = TransferManager("HTTP://%s:%s/" % (LOCAL_HOST, TRANSFER_MANAGER_PORT), self.job_queue, self.completed_queue) self.adaptor = Adaptor(self.state_manager, self.hardware_monitor, self.transfer_manager, TRANSFER_POLICY) # remote node won't start processing phase until bootstrap phase finishes self.transfer_manager.bootstrap_finished.wait() worker_thread = threading.Thread(target=worker, args=(self.job_queue, self.adaptor, self.completed_queue)) worker_thread.daemon = True worker_thread.start() self.adaptor.adapt() while True: time.sleep(1)
def play_series(self, agt1, agt2): player1_wins = 0 for i in range(self.G): print("[{}>{}]".format("-" * i, "." * (self.G - i - 1)), end="\r") game = StateManager(size=self.get_size()) if i == self.G - 1: print_game = input("Print the last game? (Y/n): ") else: print_game = "n" move_counter = 0 while not game.is_game_over(): game_state = game.get_nn_state() player_turn = game_state[0] if player_turn == 1: predictions = agt1.predict(game_state) else: predictions = agt2.predict(game_state) legal_moves = game.get_legal_moves() if move_counter < topp_random_moves * 2: move = random.choice(legal_moves) else: move = legal_moves[np.argmax(predictions)] game.move(move) move_counter += 1 if print_game.lower() == "y": game.print_board() if game.get_winner() == 1: player1_wins += 1 print("{} won {}/{} against {}.".format(agt1.name, player1_wins, self.G, agt2.name))
def tree_policy_select(self, parent, children, is_first_iteration): if is_first_iteration: selected_child = children[random.randrange(0, len(children))] return selected_child size = int((len(parent.state) - 1) ** 0.5) parent_state = StateManager(size, parent.state) if parent_state.player1_to_move: max_Q = 0.0 selected_child = None for child in children: Q = child.get_Q(parent_state.player1_to_move) + np.sqrt(np.log(parent.num_traversed) / (1.0 + parent.num_traversed_edge(child.state))) if Q > max_Q or selected_child == None: max_Q = Q selected_child = child else: max_Q = 0.0 selected_child = None for child in children: Q = child.get_Q(parent_state.player1_to_move) + np.sqrt(np.log(parent.num_traversed) / (1.0 + parent.num_traversed_edge(child.state))) if Q < max_Q or selected_child == None: max_Q = Q selected_child = child return selected_child
import RPi.GPIO as GPIO import elemental_api_class as liveapi from s_av_ctrl import StreamAvailController as StreamAvailCtrl from reloader import Reloader from state_manager import StateManager # from helpers import setup_logger # sys.path.append('/home/pi/config') import loggers as lg import config as cf try: # main_log = lg.setup_logger('main_logger','main') main_log = lg.get_main_logger() main_log.info('Starting Ad Avail Controller ver. 0.7') stater = StateManager(cf.LAST_EXIT_FILE, cf.STATE_FILE) def check_elemental_connection(): global main_log live_api = liveapi.Elemental_api(cf.elemental_ip) try: response = live_api.list_live_events() if response.status_code != 200: raise Exception("Elemental server error: {}".format( response.status_code)) except Exception as e: main_log.error('Error: {}'.format(e)) # Set-up state manager # Make a new dict with GPIs as Keys and (class)StreamAvailCtrl as values
from database import Database from state_manager import StateManager from states import * import shared import sys if __name__ == "__main__": # allow database input if len(sys.argv) == 1: db_file = "db/database.db" else: db_file = sys.argv[1] shared.db = Database(db_file) # initialize state manager and insert all used states sm = StateManager() sm.add_state(LoginState(), "login") sm.add_state(PostState(), "post") sm.add_state(MenuState(), "menu") sm.add_state(QuestionState(), "question") sm.add_state(SearchState(), "search") sm.add_state(AnswerState(), "answer") sm.add_state(EditState(), "edit") sm.start("login")
def update(self): self.state.update() self.busy = self.state.busy self.led = GREEN if not self.busy else BLUE if __name__ == '__main__': import buttonshim import signal from state_manager import StateManager from states import states buttonshim.set_pixel(*BLUE) state_manager = StateManager(states) app = App(state_manager) BUTTONS = [ buttonshim.BUTTON_A, buttonshim.BUTTON_B, buttonshim.BUTTON_C, buttonshim.BUTTON_D, buttonshim.BUTTON_E ] button_was_held = False @buttonshim.on_press(BUTTONS) def press_handler(button, pressed): global button_was_held button_was_held = False
def __init__(self, args): """Pass in args as dict. Include: startTime endTime resourceList attackerList defenderList dtCost prCost DEF - [] ATT - [] """ # Initialize state variables self.params = {} self.params["startTime"] = args["startTime"] self.params["endTime"] = args["endTime"] self.params["currentTime"] = 0 self.params["downTime"] = args["downTime"] self.params["resourceReports"] = {} self.params["downTime"] = args["downTime"] self.attackerList = [] self.defenderList = [] self.gameState = 1 self.askAtt = True self.askDef = True self.simType = 1 self.utilType = 'Logistic2P' self.attSwitch = True # For NO-OP, may not use this self.defSwitch = True # FOr NO-OP, may noy use this # token = "probe" # Shift all these into inside the strategies self.debug = 0 # Initialize the utility parameters self.initUtility(args) # Remove this before pushing to prod # debugging.refreshLog() # Initialize environment settings if (args["missRate"] != 0): self.missRate = args["missRate"] self.probeCountdown = -1 # debugging.log("miss rate set as " + str(self.missRate)) else: self.missRate = None # debugging.log("miss rate is None") if (args["falseRate"] != 0): self.falseRate = args["falseRate"] # debugging.log("Lambda is " + str(self.falseRate)) else: self.falseRate = None # debugging.log("Lambda is None") # Set the agent strategies in these self.defStrategy = None self.attStrategy = None for k, v in args["defenderList"].iteritems(): self.defStrategy = v for k, v in args["attackerList"].iteritems(): self.attStrategy = v # Initialize the state manager and the resources self.stateManager = StateManager(**{ "resourceList": args["ResourceList"], "alpha": args["alpha"] }) self.params["resourceReports"] = self.stateManager.resourceReportList # Initialize the agents self.initAgents(args) # Initialize the event queue f = (self.params["endTime"], 0, -1) self.eventQueue = [f] if self.falseRate is not None: self.getFakeProbe()
# TODO: Safer Backups -> in case if the app cannot open json + file is not empty -> safe to another file and inform user about the occured error #!/bin/python3 from state_manager import StateManager from display_utils import display_screen from constants import STATE_FILENAME # Validate if the application launched correctly if __name__ != "__main__": raise Exception("This application file cannot be a part of another app.") # # Get last saved state state = StateManager("_state.json") # Start the loop display_screen(state)
def __init__(self, game_type, game_config): self.state_manager = StateManager(game_type, game_config) self.root = None self.c = game_config["c"] # Exploration constant self.state_manager.init_new_game()
from state_manager import StateManager from track import Track def parse_raw_track(raw_track): split = raw_track.split(",") return Track(int(split[0]), split[1], split[2:]) tracks_file = open("data/tracks.txt") tracks = [parse_raw_track(raw_track) for raw_track in tracks_file.read().split("\n")] tracks_file.close() state_manager = StateManager(tracks) should_save = state_manager.await_next_command() if should_save: tracks_file = open("data/tracks.txt", "w") tracks_file.write("\n".join(track.serialize() for track in tracks)) tracks_file.close()
anchor=kytten.ANCHOR_CENTER, theme=gTheme, on_escape=on_escape) if __name__ == '__main__': window = pyglet.window.Window(800, 600, caption='Kytten Theme Editor', resizable=True, vsync=True) batch = pyglet.graphics.Batch() bg_group = pyglet.graphics.OrderedGroup(0) fg_group = pyglet.graphics.OrderedGroup(1) # Update as often as possible (limited by vsync, if not disabled) window.register_event_type('on_update') def update(dt): window.dispatch_event('on_update', dt) pyglet.clock.schedule(update) # StateManager keeps track of what we're doing manager = StateManager(window) # Start off by picking the theme directory manager.push(ThemeDirSelectState()) pyglet.app.run()
execute_parser = sub_parsers.add_parser(action_execute) execute_parser.add_argument("task_id", help="The task-id to be executed", type=int) parser.add_argument( "-d", "--dev", help="Run API in development mode (when executing from a CLI)", action="store_true", ) args = parser.parse_args() task_manager = None state_manager = StateManager() if args.dev: logging.basicConfig(level=logging.DEBUG) # noinspection PyBroadException try: if args.action == action_get: if args.state_id: state = state_manager.get_state(args.state_id) else: state = state_manager.get_latest_state(args.file_path) context = json.loads(args.context) if args.context else None task_manager = TaskManager() tasks = task_manager.get_suggested_tasks(state, context)
PORT = 5001 APP_PORT = 5000 HEROKU_HOSTNAME = "http://jeremysmorgan.herokuapp.com" #HEROKU_HOSTNAME = "https://39fd2a0aabbc.ngrok.io" APP_DIRECTORY = "/home/pi/Desktop/led-matrix-app" APP_CMD = f"python3.6 {APP_DIRECTORY}/app.py" NGROK_CYCLE_TIME_SEC = 30 * 60 # Configs hypervisor_ngrok_manager_cfg = { "port": PORT, "cycle_time": NGROK_CYCLE_TIME_SEC, } state_manager_config = {"app_command": APP_CMD, "app_directory": APP_DIRECTORY} state_manager = StateManager(state_manager_config) state_manager.run() hypervisor_ngrok_manager = NgrokManager(hypervisor_ngrok_manager_cfg) hypervisor_ngrok_manager.start_tunnel() exit_thread = False def send_json_post(url: str, json_data: dict, verbose=False): """ Send a POST request with json data """ try: req = requests.post(url, json=json_data) if verbose: print("response:", req)
from kitchen_sink_logger import KitchenSinkLogger from handler.firehose import KinesisFirehoseHandler from json_formatter.json import SimpleJsonFormatter from backpack import Backpack from state_manager import StateManager import time import logging logger = KitchenSinkLogger() logger.with_level(logging.INFO) handler = KinesisFirehoseHandler(stream_name='STREAM_NAME') handler.setFormatter(SimpleJsonFormatter()) logger.with_handler(handler) logger.with_timer("TestTimer") time.sleep(2) logger.with_timer("SecondTimer") logger2 = logger.clone() logger.with_item('test', 'value') j = logger.backpack.to_json() sm = StateManager(TableName='BackpackState') sm.upsert(logger.backpack) logger.backpack = sm.get(logger.backpack.id) logger.info('starting') logger.log_metric("Getting data", "ReadsPerSecond", 100)
def __init__(self, model, view): pygame.init() self.model = model self.view = view self.state_manager = StateManager() self.state_manager.push(States.MENU)