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)
