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)