def __init__(self, title_txt="File Browser", button_txt="Okay", cls="filedialog", path=None):
if not path: self.curdir = os.getcwd()
else: self.curdir = path
import app
self.dir_img = basic.Image(app.App.app.theme.get(cls+'.folder', '', 'image'))
td_style = {'padding_left': 4,
'padding_right': 4,
'padding_top': 2,
'padding_bottom': 2}
self.title = basic.Label(title_txt, cls=cls+".title.label")
self.body = table.Table()
self.list = area.List(width=350, height=150)
self.input_dir = input.Input(cls=cls+".input")
self.input_file = input.Input(cls=cls+".input")
self._list_dir_()
self.button_ok = button.Button(button_txt)
self.body.tr()
self.body.td(basic.Label("Path", cls=cls+".label"), style=td_style, align=-1)
self.body.td(self.input_dir, style=td_style)
self.body.tr()
self.body.td(basic.Label("File", cls=cls+".label"), style=td_style, align=-1)
self.body.td(self.input_file, style=td_style)
self.body.td(self.button_ok, style=td_style)
self.body.tr()
self.body.td(self.list, colspan=3, style=td_style)
self.list.connect(CHANGE, self._item_select_changed_, None)
self.button_ok.connect(CLICK, self._button_okay_clicked_, None)
self.value = None
Dialog.__init__(self, self.title, self.body)
def get_input_instance():
init()
input_instance = input.Input(tokens, train_string_input,
train_binary_result, test_string_input,
test_binary_result)
return input_instance
def __init__(self, tx):
self.version = version.Version(tx)
self.input_count = input_count.InputCount(tx)
if self.input_count.value == 0:
self.segwit = segwit.Segwit(tx)
self.input_count = input_count.InputCount(tx)
else:
self.segwit = None
self.inputs = []
for i in range(self.input_count.value):
self.inputs.append(input.Input(tx))
self.output_count = output_count.OutputCount(tx)
self.outputs = []
for i in range(self.output_count.value):
self.outputs.append(output.Output(tx))
if self.segwit is not None:
for i in range(self.input_count.value):
self.witness_count = witness_count.WitnessCount(tx)
self.witnesss = []
if self.witness_count != 0:
for i in range(self.witness_count.value):
self.witnesss.append(witness.Witness(tx))
else:
self.witnesss.append(None)
self.locktime = locktime.Locktime(tx)
def parcours(self):
pos = 0
pos = self.version.parcours(pos, self)
pos = self.inputCount.parcours(pos, self)
for i in range(self.inputCount.decimal):
self.input = input.Input()
pos = self.input.txid.parcours(pos, self)
pos = self.input.vout.parcours(pos, self)
d = pos
pos = self.input.scriptSigSize.parcours(pos, self)
self.input.scriptSig.length = int(self.raw[d:pos], 16)
pos = self.input.scriptSig.parcours(pos, self)
pos = self.input.sequence.parcours(pos, self)
self.inputs.append(self.input)
if pos != len(self.raw):
pos = self.outputCount.parcours(pos, self)
for i in range(self.outputCount.decimal):
self.output = output.Output()
pos = self.output.value.parcours(pos, self)
d = pos
pos = self.output.scriptPubKeySize.parcours(pos, self)
self.output.scriptPubKey.length = int(self.raw[d:pos], 16)
pos = self.output.scriptPubKey.parcours(pos, self)
self.outputs.append(self.output)
if pos != len(self.raw):
pos = self.locktime.parcours(pos, self)
def __init__(self):
self.WINDOWWIDTH, self.WINDOWHEIGHT = (600, 800)
input.Input.winSize = [self.WINDOWWIDTH, self.WINDOWHEIGHT]
self.screen = pygame.display.set_mode(
(self.WINDOWWIDTH, self.WINDOWHEIGHT))
self.FPSClock = pygame.time.Clock()
self.FPS = 60
self.input = input.Input()
sound.muted = False
self.IMAGESCALEUP = 4
self.screenShakeOffset = [0, 0]
self.grey = (60, 60, 60)
self.white = (250, 250, 250)
self.lightgrey = (170, 170, 170)
self.yellow = (255, 223, 134)
self.scoreValues = {
'shoot bomb': 20,
'shoot superBomb': 30,
'destroy bomber': 200
}
def main(_):
config = cf.Config()
eval_config = cf.Config()
eval_config.batch_size = 1
eval_config.num_steps = 1
train_data, valid_data, test_data, _ = ip.get_raw_data(config.data_path)
with tf.Graph().as_default():
initializer = tf.random_uniform_initializer(-config.init_scale, config.init_scale)
with tf.name_scope("Train"):
train_input = ip.Input(config=config, data=train_data, name="TrainInput")
with tf.variable_scope("Model", reuse=None, initializer=initializer):
m = lm.LMModel(is_training=True, config=config, inputs=train_input)
tf.summary.scalar("Training Loss", m.cost)
tf.summary.scalar("Training Rate", m.lr)
with tf.name_scope("Valid"):
valid_input = ip.Input(config=config, data=valid_data, name="ValidInput")
with tf.variable_scope("Model", reuse=True, initializer=initializer):
mvalid = lm.LMModel(is_training=False, config=config, inputs=valid_input)
tf.summary.scalar("Validation Loss", mvalid.cost)
with tf.name_scope("Test"):
test_input = ip.Input(config=eval_config, data=test_data, name="TestInput")
with tf.variable_scope("Model", reuse=True, initializer=initializer):
mtest = lm.LMModel(is_training=False, config=eval_config, inputs=test_input)
sv = tf.train.Supervisor(logdir=config.save_path)
config_proto = tf.ConfigProto(allow_soft_placement=False)
with sv.managed_session(config=config_proto) as session:
for i in range(config.max_epoch):
lr_decay = config.lr_decay ** max(i + 1 - config.lr_const_epoch, 0)
m.update_lr(session, config.learning_rate * lr_decay)
print("Epoch: %d Learning rate: %.3f" % (i + 1, session.run(m.lr)))
train_perplexity = run_epoch(session, m, eval_op=m.optim, verbose=True)
print("Epoch: %d Train Perplexity: %.3f" % (i + 1, train_perplexity))
valid_perplexity = run_epoch(session, mvalid)
print("Epoch: %d Valid Perplexity: %.3f" % (i + 1, valid_perplexity))
test_perplexity = run_epoch(session, mtest)
print("Test Perplexity: %.3f" % test_perplexity)
print("Saving model to %s." % config.save_path)
sv.saver.save(session, config.save_path, global_step=sv.global_step)
def __init__(self,
title_txt="File Browser",
button_txt="Okay",
cls="dialog",
path=None):
"""FileDialog constructor.
Keyword arguments:
title_txt -- title text
button_txt -- button text
path -- initial path
"""
cls1 = 'filedialog'
if not path: self.curdir = os.getcwd()
else: self.curdir = path
self.dir_img = basic.Image(
pguglobals.app.theme.get(cls1 + '.folder', '', 'image'))
td_style = {
'padding_left': 4,
'padding_right': 4,
'padding_top': 2,
'padding_bottom': 2
}
self.title = basic.Label(title_txt, cls=cls + ".title.label")
self.body = table.Table()
self.list = area.List(width=350, height=150)
self.input_dir = input.Input()
self.input_file = input.Input()
self._list_dir_()
self.button_ok = button.Button(button_txt)
self.body.tr()
self.body.td(basic.Label("Folder"), style=td_style, align=-1)
self.body.td(self.input_dir, style=td_style)
self.body.tr()
self.body.td(self.list, colspan=3, style=td_style)
self.list.connect(CHANGE, self._item_select_changed_, None)
self.button_ok.connect(CLICK, self._button_okay_clicked_, None)
self.body.tr()
self.body.td(basic.Label("File"), style=td_style, align=-1)
self.body.td(self.input_file, style=td_style)
self.body.td(self.button_ok, style=td_style)
self.value = None
Dialog.__init__(self, self.title, self.body)
def __init__(self):
print 'Initializing game.'
#using pygame
pygame.init()
self.clock = pygame.time.Clock()
self.paddle = o.Paddle()
self.ball = o.Ball()
self.block_container = o.BlockContainer()
self.screen = s.Screen(pygame)
self.input = i.Input(pygame)
def __init__(self, data):
super().__init__()
self.controller = input.Input()
self.controllers = []
self.mode = "controller"
self.joyInstruct = pygame.image.load(
os.path.join('assets', 'controller.png'))
self.keyInstruct = pygame.image.load(
os.path.join('assets', 'keyboard.png'))
pygame.joystick.init()
for i in range(pygame.joystick.get_count()):
pygame.joystick.Joystick(i).init()
def __init__(self, data_path):
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
self.input_device = input.Input()
self.hid_device = bt_hid.BluetoothHID(data_path)
self.hid_device.init()
self.input_device.register_callbacks(self.key_callback,
self.mouse_move_callback,
self.mouse_button_callback,
self.mouse_wheel_callback)
self.clients = {}
self.client = None
self.active_keys = set()
self.ignore_keys = set()
def processEvent(self, data, event):
if event.type == pygame.JOYBUTTONUP:
if len(
self.controllers
) < 2 and event.button == 1 and event.joy not in self.controllers:
self.controllers.append(event.joy)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_k:
self.mode = "keyboard"
elif event.key == pygame.K_j:
self.mode = "controller"
elif event.key == pygame.K_RETURN:
if self.mode == "controller" and len(self.controllers) == 2:
data.scene = game.Game(data, [
input.Input(joystick=pygame.joystick.Joystick(j))
for j in self.controllers
])
elif self.mode == "keyboard":
data.scene = game.Game(data, [
input.Input(input.KEYBOARD_P1),
input.Input(input.KEYBOARD_P2)
])
def __init__(self):
"""Start the program"""
#sound.startMusic()
pygame.display.set_caption('Juggleball')
screen.fill((135, 206, 250))
pygame.display.update()
pygame.time.wait(400)
self.input = input.Input()
self.mode = 'menu'
self.menu = MenuScreen('Press SPACE to play Juggleball')
FPSClock.tick(60)
self.highScore = 0
self.isFirstGame = True
sound.play('whoosh')
def __init__(self, data):
super().__init__()
self.logo = pygame.image.load(os.path.join('assets', 'logo.png'))
self.logoRect = self.logo.get_rect()
self.logoRect.center = (data.width / 2, data.height / 3)
self.caption = data.font.render("Press Enter to Start !", True,
(255, 255, 255))
self.captionRect = self.caption.get_rect()
self.captionRect.center = (data.width / 2, data.height * 2 / 3)
self.help = data.font.render("Press H for instructions", True,
(255, 255, 255))
self.helpRect = self.help.get_rect()
self.helpRect.bottomright = (data.width - 10, data.height - 5)
self.controller = input.Input()
self.exitCount = 0
def __init__(self):
pyxel.init(constants.GAME_WIDTH,
constants.GAME_HEIGHT,
caption=constants.GAME_TITLE,
fps=constants.GAME_FPS,
scale=constants.GAME_SCALE)
pyxel.load(constants.RESOURCE_FILE)
pyxel.image(0).load(0, 0, constants.IMAGE_BANK_0_FILE)
self.input = input.Input()
self.game = game.Game()
pyxel.mouse(False)
#pyxel.mouse(True)
pyxel.run(self.update, self.draw)
def __init__(self):
if not WINDOWEDMODE:
screenInfo = pygame.display.Info()
self.WINDOWWIDTH, self.WINDOWHEIGHT = (screenInfo.current_w,
screenInfo.current_h)
self.screen = pygame.display.set_mode(
(self.WINDOWWIDTH, self.WINDOWHEIGHT), FULLSCREEN)
if WINDOWEDMODE:
self.WINDOWWIDTH, self.WINDOWHEIGHT = (1450, 1050)
self.screen = pygame.display.set_mode(
(self.WINDOWWIDTH, self.WINDOWHEIGHT))
self.gameSurf = pygame.Surface(self.screen.get_size())
self.gameSurf.convert()
self.FPS = 60
self.FPSClock = pygame.time.Clock()
self.FPSClock.tick(self.FPS) # so the first dt value isnt really weird
self.input = input.Input()
self.keybinds = {
'left': [K_LEFT, K_a],
'right': [K_RIGHT, K_d],
'jump': [K_SPACE, K_UP, K_w],
'pull': [K_LSHIFT, K_LCTRL]
}
self.currentLevel = 0 # TEMP FOR TESTING should normally be = 0
self.CELLSIZE = 64
self.TIMESTEP = 1.0 / self.FPS
self.PPM = float(self.CELLSIZE)
self.WHITE = (255, 255, 255)
self.BLACK = (0, 0, 0)
self.RED = (220, 20, 20)
self.SKYBLUE = (135, 206, 250)
self.DARKBLUE = (0, 35, 102)
self.YELLOW = (255, 255, 102)
self.DARKYELLOW = (204, 204, 0)
self.GREEN = (110, 255, 100)
self.ORANGE = (255, 165, 0)
self.DARKGREY = (60, 60, 60)
self.LIGHTGREY = (180, 180, 180)
self.CREAM = (255, 255, 204)
def __init__ (self, w, h, titulo):
pygame.init()
window = pygame.display.set_mode((w, h), HWSURFACE|DOUBLEBUF)
pygame.mouse.set_visible(False)
self.nome = titulo
self.dimensoes = [w, h]
self.tela = pygame.display.get_surface()
self.layers = [[],[],[],[],[],[]]
self.loop = 1
self.sprites = {}
self.clock = 1
self.input = input.Input(self)
self.clock = pygame.time.get_ticks()
self.lastUpdate = self.clock
self.conteiner = {}
self.grupocolisao = []
self.colisao = colisao.Colisao(self)
print "-- Engine Carregada"
def main(stdscr):
curses.curs_set(0)
stdscr.noutrefresh()
main_input = input.Input(stdscr)
main_map = map.Map(100, 100, rooms=20)
player = entity.Entity(*main_map.room_list[0].center.point)
main_map.put_entity(player)
map_display = display.DisplayMapScroll(main_map,
player,
20, 80,
150, 150)
hook_display = display.DisplayHook(map_display,
Orientation.bottom,
4, 20)
hook_to_hook_display = display.DisplayHook(hook_display,
Orientation.right,
4, 10)
map_display.refresh_map()
hook_display.refresh()
hook_to_hook_display.refresh()
Display.update()
done = False
while not done:
key = main_input.get_move_key()
main_map.erase_entity(player)
player.move(key)
main_map.put_entity(player)
hook_display.print_screen(str(player.pos.point), 0, 0)
map_display.refresh_map()
Display.update()
if key == entity.Move.done:
done = True
def get_input_instance(items_kfold_str, with_recipe):
global items_kfold
global is_with_recipe
items_kfold = items_kfold_str
is_with_recipe = with_recipe
init()
# tokens,
# trainStrInput,
# trainBinaryResult,
# testStrInput,
# testBinaryResult
input_instance = input.Input(fill_tokens(), fill_string_input('true'),
fill_binary_result('true'),
fill_string_input('false'),
fill_binary_result('false'))
return input_instance
def __init__(self,
title="",
default="",
editable=True,
special_button=None):
self.list = area.List(width=350, height=150)
self.list.connect(CHANGE, self.itemClicked, None)
self.journalItems = []
okButton = button.Button("Okay",
style={
'width': 80,
'height': 28,
'margin': 8
})
okButton.connect(CLICK, self.okayClicked)
cancelButton = button.Button("Cancel",
style={
'width': 80,
'height': 28,
'margin': 8
})
cancelButton.connect(CLICK, self.close)
self.input_item = input.Input(default)
self.input_item.connect(CHANGE, self.itemTyped, None)
self.input_item.disabled = not editable
body = table.Table()
body.tr()
body.td(basic.Label(title), colspan=2)
body.tr()
body.td(self.list, colspan=2)
body.tr()
if special_button:
body.td(self.input_item, colspan=1)
body.td(special_button, colspan=1)
else:
body.td(self.input_item, colspan=2)
body.tr()
body.td(okButton)
body.td(cancelButton)
Dialog.__init__(self, basic.Label(title), body)
def main():
'''
shape
(2, 6)
statistics
District Latitude Longitude
count 2.000000 2.0 2.0
mean 11.500000 0.0 0.0
std 9.192388 0.0 0.0
min 5.000000 0.0 0.0
25% 8.250000 0.0 0.0
50% 11.500000 0.0 0.0
75% 14.750000 0.0 0.0
max 18.000000 0.0 0.0
data samples 10 rows
Date Description District Primary Type Latitude Longitude
idx
2017-04-01 11:05:00 04/01/2017 11:05:00 AM FROM BUILDING 18 THEFT 0.0 0.0
2017-03-20 21:05:00 03/20/2017 09:05:00 PM $500 AND UNDER 5 THEFT 0.0 0.0
Date Description District Primary Type Latitude Longitude
idx
2017-04-01 11:05:00 04/01/2017 11:05:00 AM FROM BUILDING 18 THEFT 0.0 0.0
2017-03-20 21:05:00 03/20/2017 09:05:00 PM $500 AND UNDER 5 THEFT 0.0 0.0
'''
path = r"src\crime.csv"
iii = input.Input(path)
row_num = 10000
col_name = [
'Date', 'Description', 'District', 'Primary Type', 'Latitude',
'Longitude'
]
year = 2017
nan_not_allowed = 1
primary_type = 'THEFT'
time_range = ['2017-03-20', '2017-4-01']
arrest = 2
s = iii.data_extract(row_num, col_name, year, nan_not_allowed,
primary_type, time_range, arrest)
print(s)
def main_loop():
global silence_time
button = io.Input()
#debug_point = 1397 # debug
while True:
#shift_data = closest_checkpoint(debug_point)
shift_data = closest_checkpoint()
print('#### MAIN LOOP ####')
print(shift_data)
while shift_data['check_time']:
time_now = get_int_time_now()
#time_now = 1398
if shift_data['stop'] > time_now:
beep(B_WARN)
elif shift_data['stop'] == time_now:
beep(B_FAIL)
print('SYSTEM IN PAUSE FOR 60 SECONDS DUE TO SHIFT FAIL')
time.sleep(60)
break
if button.watch_file() == HIGH:
beep(B_OK)
delay_time = ((shift_data['stop'] - time_now) + 1) * 60
print('SYSTEM IN PAUSE FOR {} SECONDS'.format(delay_time))
# force pause until check_time is false, avoiding this loop
#time.sleep(10)
time.sleep(delay_time)
debug_point = 1402 # debug
break
time.sleep(.4)
# 1 - if it's checkpoint time, set flag with start and keep warning period
# 2 - keep checking for input HIGH or LOW, while beep(B_WARN)
# 3 - keep checking for end warning period
""" new_input = button.watch_file()
def run():
my.input = input.Input()
menu = MainMenu()
my.transition = -1 # fade between menus/game states
if my.gameRunning: # debug mode is enabled
handler = logic.Handler()
else:
pygame.time.wait(600) # pause for effect
while True: # main game loop
deltaTime = my.FPSCLOCK.tick(my.FPS)
if my.gameRunning:
handler.update(deltaTime / 1000.0) # update the game
else: # display menu
nextMenu = menu.update()
if nextMenu == 'main':
menu = MainMenu()
elif nextMenu == 'embark':
menu = EmbarkMenu()
elif nextMenu == 'credits':
menu = CreditsMenu()
elif nextMenu == 'quit':
my.input.terminate()
elif nextMenu == 'play':
handler = logic.Handler() # start a new game
if my.transition == 'begin':
my.transition = 255
if my.transition > 0:
my.transition -= 3 * deltaTime / 17
my.lastSurf.set_alpha(my.transition)
my.screen.blit(my.lastSurf, (0, 0))
pygame.display.update()
pygame.display.set_caption('Aedificus: Fathers of Rome' + ' ' * 10 + 'FPS: ' + str(int(my.FPSCLOCK.get_fps())))
def __init__(self):
self.game_state = self.State.INITIALIZING
os.environ["SDL_VIDEO_CENTERED"] = "1"
pygame.init()
self.frame_timer = pygame.time.Clock()
self.input_handler = input.Input()
self.input_handler.add_listener(self)
self.main_menu = menu.Menu()
self.main_menu.add_listener(self)
self.file_handler = filehandler.FileHandler()
self.settings = {"GridWidth": 10, "GridHeight": 10, "MineCount": 20}
proposed_grid_width = self.file_handler.get_setting("GridWidth", 5, 35)
if proposed_grid_width != None:
self.settings["GridWidth"] = proposed_grid_width
proposed_grid_height = self.file_handler.get_setting(
"GridHeight", 5, 30)
if proposed_grid_height != None:
self.settings["GridHeight"] = proposed_grid_height
proposed_mine_count = self.file_handler.get_setting(
"MineCount", 1,
self.settings["GridWidth"] * self.settings["GridHeight"] - 1)
if proposed_mine_count != None:
self.settings["MineCount"] = proposed_mine_count
def make_input(self,name,value,zero_after=None):
self.add(input.Input(name,value,zero_after=zero_after))
def run_training():
"""Train MNIST for a number of steps."""
# Tell TensorFlow that the model will be built into the default Graph.
with tf.Graph().as_default():
# Generate placeholders for the images and labels.
state_placeholder, action_placeholder = placeholder_inputs()
game = input.Input(3, 2)
def multilayer_perceptron(_X, _weights, _biases):
layer_1 = tf.nn.relu(
tf.add(tf.matmul(_X, _weights['h1']), _biases['b1']))
layer_2 = tf.nn.relu(
tf.add(tf.matmul(layer_1, _weights['h2']), _biases['b2']))
return tf.matmul(layer_2, _weights['out']) + _biases['out']
# Store layers weight & bias
weights = {
'h1': tf.Variable(tf.random_normal([75, 75])),
'h2': tf.Variable(tf.random_normal([75, 40])),
'out': tf.Variable(tf.random_normal([40, 3]))
}
biases = {
'b1': tf.Variable(tf.random_normal([75])),
'b2': tf.Variable(tf.random_normal([40])),
'out': tf.Variable(tf.random_normal([3]))
}
# Construct model
pred = multilayer_perceptron(state_placeholder, weights, biases)
# Add to the Graph the Ops for loss calculation.
loss = arch.loss(pred, action_placeholder)
# Add to the Graph the Ops that calculate and apply gradients.
train_op = arch.training(loss, FLAGS.learning_rate)
# Build the summary operation based on the TF collection of Summaries.
r = []
l = []
x = []
t = []
summary_op = tf.merge_all_summaries()
# Add the variable initializer Op.
init = tf.initialize_all_variables()
# Create a saver for writing training checkpoints.
saver = tf.train.Saver(tf.all_variables())
# Create a session for running Ops on the Graph.
sess = tf.Session()
# Instantiate a SummaryWriter to output summaries and the Graph.
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph)
# And then after everything is built:
# Run the Op to initialize the variables.
sess.run(init)
#ckpt = tf.train.get_checkpoint_state(FLAGS.train_dir)
#if ckpt and ckpt.model_checkpoint_path:
# print('Loading ' + ckpt.model_checkpoint_path)
# # Restores from checkpoint
#saver.restore(sess, "data/model_1.ckpt")
model_num = 0 #int(ckpt.model_checkpoint_path.split("_")[1].split(".")[0]) + 1
print(model_num)
epsilon = 1
wins = 0
game_length = np.zeros(100)
avg_score = np.zeros(100)
xs = 0
steps = 0
avg_loss = np.zeros(100)
avg_loss.fill(100)
avg_score.fill(-100)
print('Start Training...')
# Start the training loop.
for step in xrange(EPOCHS):
#start_time = time.time()
game.restart()
status = 1
turns = 0
print("Game #: " + str(step), end="")
while status == 1:
#We are in state S
#Let's run our Q function on S to get Q values for all possible actions
state = game.grid()
qval = sess.run(
pred, feed_dict={state_placeholder: state.reshape(1, 75)})
if (random.random() < epsilon): #choose random action
action = np.random.randint(0, 3)
else: #choose best action from Q(s,a) values
action = (np.argmax(qval))
#Take action, observe new state S'
game.move(action)
new_state = game.grid()
#Observe reward
reward = game.reward()
#Get max_Q(S',a)
newQ = sess.run(
pred,
feed_dict={state_placeholder: new_state.reshape(1, 75)})
maxQ = np.max(newQ)
y = np.zeros((1, 3))
y[:] = qval[:]
if reward < -1: #non-terminal state
update = (reward + (GAMMA * maxQ))
else: #terminal state
update = reward
y[0][action] = update #target output
feeddict = fill_feed_dict(state.reshape(1, 75), y,
state_placeholder,
action_placeholder)
_, loss_value = sess.run([train_op, loss], feed_dict=feeddict)
avg_loss[turns % 100] = loss_value * 100
turns += 1
if game.total_out(-1) + game.pits != 3:
game.display()
print('pits')
print(turns)
if game.total_out(1) + game.goals != 2:
game.display()
print('goals')
print(turns)
if reward < -1 or turns >= TURN_BOUNDRY:
status = 0
print(" - Turns: %d" % (turns), end="")
print(" - EC: %.2f" % (game.total_score))
if len(game_length) >= 100:
game_length[steps % 100] = turns
avg_score[steps % 100] = game.total_score
else:
game_length.append(turns)
avg_score.append(game.total_score)
if turns >= 1000:
wins += 1
if epsilon > 0.001:
epsilon -= (1 / EPOCHS)
#duration = time.time() - start_time
if step == 0 or (step + 1) % 100 == 0:
# Print status to stdout.
print(
'Step %d: loss = %.2f, avg game len = %.2f, avg score = %.2f, wins = %d'
% (step, np.mean(avg_loss), np.mean(game_length),
np.mean(avg_score), wins))
# Update the events file.
#summary_str = sess.run(summary_op, feed_dict=feeddict)
#summary_writer.add_summary(summary_str, step)
if step == 0 or (step + 1) % 10 == 0:
r.append(np.mean(avg_score))
l.append(np.mean(avg_loss))
t.append(np.mean(game_length))
xs += 1
x.append(xs * 10)
if (step + 1) % (1000) == 0:
save_path = saver.save(
sess, "data/model_" + str(model_num) + ".ckpt")
print("Model saved in file: %s" % save_path)
model_num += 1
turns = 0
game.restart()
status = 1
while status == 1:
game.display()
#We are in state S
#Let's run our Q function on S to get Q values for all possible actions
state = game.grid()
qval = sess.run(
pred,
feed_dict={state_placeholder: state.reshape(1, 75)})
if (random.random() < epsilon): #choose random action
action = np.random.randint(0, 3)
print('r')
else: #choose best action from Q(s,a) values
action = (np.argmax(qval))
print('c')
#Take action, observe new state S'
game.move(action)
new_state = game.grid()
#Observe reward
reward = game.reward()
turns += 1
if reward < -1 or turns >= 100:
status = 0
game.display
print(turns, game.total_score)
steps += 1
if wins > 0:
r.append(np.mean(avg_score))
l.append(np.mean(avg_loss))
t.append(np.mean(game_length))
xs += 1
x.append(xs * 10)
break
print(r, l, t, x)
plt.plot(x, l, 'b')
plt.plot(x, r, 'r')
plt.plot(x, t, 'g')
plt.axis([0, 1000, -100, 2000])
plt.show()
def __init__(self):
super().__init__()
self.help = pygame.image.load(os.path.join('assets', 'help.jpg'))
self.y = 0
self.controller = input.Input()
def load(inputPath, configPath):
'''
Populates input parameters via YAML input; converts and validates parameters.
Input(s): inputPath (str), configPath (str) \n
Output(s): <none>
'''
# YAML parse
configDict = util_yaml.load(configPath)
inputDict = util_yaml.load(inputPath)
inputDict = util_yaml.process(inputDict)
# Instantiate input object
inp = input.Input()
# Param config: min, max, quantity
for group in configDict.keys():
for param in configDict[group].keys():
for field in configDict[group][param].keys():
value = configDict[group][param][field]
setattr(getattr(getattr(inp, group), param), field, value)
# Param assignment: value, unit, dist
for group in inputDict.keys():
for param in inputDict[group].keys():
# Multiple fields specified by user
if (isinstance(inputDict[group][param], dict)):
for field in inputDict[group][param].keys():
value = inputDict[group][param][field]
setattr(getattr(getattr(inp, group), param), field, value)
# Only "value" is specified by user
else:
value = inputDict[group][param]
getattr(getattr(inp, group), param).value = value
# Param conversion & validation
util_unit.config()
for group in inputDict.keys():
for param in inputDict[group].keys():
obj = getattr(getattr(inp, group), param)
if (isinstance(obj, input.Param)):
obj.value = util_unit.convert(obj.value, obj.quantity,
obj.unit)
print("value: ", obj.value)
cond = obj.check_value()
elif (isinstance(obj, input.Name)):
cond = obj.check_path()
print(param + ": ", cond)
def readFile(self):
# Reading the graph from the input file
self.graphInput = input.Input()
self.graphInput.readFile('input.json')
def __init__(self):
self.WINDOWWIDTH, self.WINDOWHEIGHT = (1200, 800)
self.screen = pygame.display.set_mode(
(self.WINDOWWIDTH, self.WINDOWHEIGHT))
self.FPSClock = pygame.time.Clock()
self.input = input.Input()
def __init__(self, data, game):
self.game = game
self.controller = input.Input()
self.overlay = pygame.Surface((data.width, data.height))
self.overlay.set_alpha(150)
