def run_loop(session,
modes,
models,
summary_ops=None,
logging=False,
name_modifier=""):
"""
Runs models for the specified number of epochs.
:param session: MonitoredTrainingSession to use
:param modes: List of modes. Whether to train, evaluate, or test
:param models: List of models
:param summary_ops: List of summary operations with one operation per model, or None.
:param logging: Whether to write summaries for tensorboard.
:param name_modifier: Suffix to identify the model in tensorboard. Creates a subdirectory.
:return: List of lists, where each sub-list is the loss/epoch.
"""
assert (len(modes) == len(models))
assert (summary_ops is None or len(summary_ops) == len(models))
assert (summary_ops is None or logging)
nr_models = len(modes)
representative_config = models[
0].config # used for variables that are assumed to be the same between models
writers = []
losses = []
for i in range(nr_models):
losses.append([])
if logging:
writers.append(
tf.summary.FileWriter(
log_path + os.sep + Mode.to_string(modes[i]).lower() +
name_modifier, session.graph))
else:
writers.append(None)
for i in range(representative_config.nr_epochs):
for m in range(nr_models):
model = models[m]
perplexity = run_epoch(
session,
model,
writer=writers[m],
summary_op=summary_ops[m],
eval_op=model.train_op if modes[m] == Mode.train else None)
losses[m].append(perplexity)
log("%s Epoch: %d Perplexity: %.3f" %
(Mode.to_string(modes[m]), i + 1, perplexity))
return losses
def mode_api():
if request.method == 'POST':
obj = json.loads(request.data)
mode = Mode.from_json(obj)
app.logger.info('Web mode: {}'.format(str(mode)))
app.access_base.set_mode(mode)
result = ({'status': '0'})
else:
result = app.access_base.mode().to_json()
return Response(json.dumps(result), mimetype='application/json', headers={'Cache-Control': 'no-cache'})
def run(self):
access_base = self._access_base
LOG.setLevel(logging.DEBUG)
LOG.info("Watching changes in accessbase")
while True:
if self._done_event.wait(0.100):
LOG.info("Effects done")
self._done_event.clear()
if self._player is not None and not self._player.play_next():
LOG.info("Cleaning up")
self._current_mode = Mode.stop()
self._access_base.set_mode(self._current_mode)
if access_base.wait_for_change(0.100):
if not self.current_mode().equals(access_base.mode()):
LOG.info("Accessbase has changed!")
self.apply_mode(access_base.mode())
def instantiate_model(mode, config, data_set):
"""
Instantiates the model with the given configuration and data.
:param mode: Mode enum specifying train/test/validation.
:param config:
:param data_set: a tf.data.dataset
:return: model, summary operation
"""
name = Mode.to_string(mode)
initializer = tf.random_uniform_initializer(-config.init_scale,
config.init_scale)
with tf.name_scope(name=name):
model_input = ModelInput(config=config, data=data_set)
with tf.variable_scope("Model",
reuse=tf.AUTO_REUSE,
initializer=initializer):
model = SeqModel(is_training=(mode == Mode.train),
config=config,
dataset=model_input)
summary = tf.summary.scalar(name + " Loss", model.normalized_cost)
if mode == Mode.train:
summ_lr = tf.summary.scalar("Learning Rate",
model.config.learning_rate)
summary = tf.summary.merge([summary, summ_lr])
summ_layers = tf.summary.scalar("Layers", model.config.num_layers)
summ_bs = tf.summary.scalar("Batch Size", model.config.batch_size)
summ_grad_norm = tf.summary.scalar("Gradient Norm",
model.config.max_grad_norm)
summ_keep_prob = tf.summary.scalar("Dropout Keep Probability",
model.config.keep_prob)
summ_hidden_size = tf.summary.scalar("State Size",
model.config.hidden_size)
summary = tf.summary.merge([
summary, summ_layers, summ_bs, summ_grad_norm, summ_keep_prob,
summ_hidden_size
])
return model, summary
alpha = manager.accessor()
bravo = manager.accessor()
charlie = manager.accessor()
ta = threading.Thread(target=wait_ab, args=(alpha, 'alpha'))
tb = threading.Thread(target=wait_ab, args=(bravo, 'bravo'))
tc = threading.Thread(target=wait_ab, args=(charlie, 'charlie'))
manager.change_watcher()
ta.start()
tb.start()
tc.start()
time.sleep(1)
logging.info("Changing alpha")
alpha.set_mode(Mode.stop())
time.sleep(1)
logging.info("Changing bravo")
bravo.set_mode(Mode.stop())
time.sleep(2)
logging.info("Changing charli")
charlie.set_mode(Mode.stop())
time.sleep(2)
logging.info("Changing alpha")
alpha.set_mode(Mode.stop())
def save_route():
"""User saves new route, including one stop."""
name = request.form.get('name')
start_address = request.form.get('startAddress')
stop_address = request.form.get('stopAddress')
mode = request.form.get('mode')
stop_order = request.form.get('stopOrder')
user_id = User.query.get(session['user_id']).user_id
# converting JSON to python dictionary
stop_address = eval(stop_address)
mode = eval(mode)
stop_order = eval(stop_order)
# grabbing end/final stop = last stop
# stop_address keys are strings!
max_stop = 0
end_address = stop_address['0']
for stop in stop_address.keys():
stop = int(stop)
if stop > max_stop:
stop = str(stop)
end_address = stop_address[stop]
# USE GOOGLE MAPS PLACES API TO GET LAT AND LNG
############## START ################
start_info = gmaps.places(start_address)
# list of results, but coordinates is a dictionary of first element at idx 0
start_coord = start_info['results'][0]['geometry']['location']
start_lat = start_coord['lat']
start_lng = start_coord['lng']
########## FINAL/END DESTINATION ##############
end_info = gmaps.places(end_address)
# list of results, but coordinates is a dictionary of first element at idx 0
end_coord = end_info['results'][0]['geometry']['location']
end_lat = end_coord['lat']
end_lng = end_coord['lng']
########## ALL STOPS (no start address) #############
# get all stops INCLUDING final/endstop!
stop_coord = {}
for stop in stop_address.keys():
curr_address = stop_address[stop]
curr_info = gmaps.places(curr_address)
curr_coord = curr_info['results'][0]['geometry']['location']
# save into dictionary
stop_coord[stop] = curr_coord
# store route info in routes table
new_route = Route(name=name,
start_address=start_address,
start_lat=start_lat,
start_lng=start_lng,
end_address=end_address,
end_lat=end_lat,
end_lng=end_lng,
user_id=user_id)
db.session.add(new_route)
db.session.commit()
# go through stop info and save to segments table
for stop in stop_address.keys():
stop = int(stop)
seg_start = ""
seg_start_lat = ""
seg_start_lng = ""
seg_stop = ""
seg_stop_lat = ""
seg_stop_lng = ""
# must be an integer!
mode_id = 0
order_num = 0
route_id = 0
# for the first segment, start of segment is actual start address
if stop == 0:
seg_start = start_address
seg_start_lat = start_lat
seg_start_lng = start_lng
else:
seg_start = stop_address[str(stop - 1)]
seg_start_lat = stop_coord[str(stop - 1)]['lat']
seg_start_lng = stop_coord[str(stop - 1)]['lng']
# grabbing stop addresses
seg_stop = stop_address[str(stop)]
seg_stop_lat = stop_coord[str(stop)]['lat']
seg_stop_lng = stop_coord[str(stop)]['lng']
# adding mode of this segment to modes table
# go through dictionary and save individual modes to table
md = Mode(mode=mode[str(stop)])
db.session.add(md)
db.session.commit()
mode_id = md.mode_id
order_num = stop_order[str(stop)]
route_id = new_route.route_id
# adding each segment into segments table!
segment = Segment(order_num=order_num,
start_address=seg_start,
start_lat=seg_start_lat,
start_lng=seg_start_lng,
stop_address=seg_stop,
stop_lat=seg_stop_lat,
stop_lng=seg_stop_lng,
route_id=route_id,
mode_id=mode_id)
db.session.add(segment)
db.session.commit()
return 'SUCCESS'
if __name__ == '__main__':
from server import app
# connect and create db
connect_to_db(app)
db.create_all()
# API request
data1 = get_game_data_w_offset0()
data2 = get_game_data_w_offset50()
data3 = get_game_data_w_offset100()
data4 = get_game_data_w_offset150()
# pprint(data)
# manually adding modes and adding it to Mode table under game_mode field
single_player = Mode(game_mode='Single player')
multi_player = Mode(game_mode='Multiplayer')
co_op = Mode(game_mode='Co-op')
mmo = Mode(game_mode='MMO')
split_screen = Mode(game_mode='Split screen')
# add all variables to db
db.session.add_all([single_player, multi_player, co_op, mmo, split_screen])
db.session.commit()
# hard code game modes for game_mode field in modes table
game_modes = {
'Single player': single_player,
'Multiplayer': multi_player,
'Co-operative': co_op,
'Massively Multiplayer Online (MMO)': mmo,
'Split screen': split_screen
}
def trigger_reset():
accessbase.set_mode(Mode.stop())
else:
input_reset = False
time.sleep(0.2)
if __name__ == '__main__':
root = os.path.dirname(__file__)
accessbase_path = os.path.join(root, '..', 'state')
access_base = AccessBaseManager(accessbase_path)
server_accessor = access_base.accessor('server')
effect_accessor = access_base.accessor('effectenbak')
interface_accessor = access_base.accessor('interface')
# Stop
effect_accessor.set_mode(Mode.stop())
access_base.change_watcher()
logging.info("Starting effectenbak thread")
effectenbak = threading.Thread(target=effectbak_runner, args=(effect_accessor,), name='effectenbak')
effectenbak.start()
logging.info("Starting interface thread")
interface = threading.Thread(target=interface_runner, args=(interface_accessor,), name='interface')
interface.start()
logging.info("Starting http server")
http.server.start(server_accessor)
