async def run(): async with aiohttp.ClientSession() as session: fw = framework.Framework(session, region, (20, 1), (100, 120)) fw.set_key(api_key) req = tasks.request.Request(fw) req.queue_match = queue_match await req.run()
async def run(): async with aiohttp.ClientSession(loop=loop) as session: fw = {} for r in call.REGIONS: fw[r] = framework.Framework(loop, session, r, (20, 1), (100, 120)) fw[r].set_key(api_key) res = [] for r in call.REGIONS: for a in aid[r]: task = loop.create_task(match.get_matchlist(fw[r], a)) res.append(task) task.add_done_callback(process_matchlist) await asyncio.wait(res, loop=loop, return_when="ALL_COMPLETED")
def create_inference_graph_and_load_variables(sess, FLAGS): """Creates an audio model with the nodes needed for inference. Uses the supplied arguments to create a model, and inserts the input and output the trained model graph. """ model_settings = data_utils.prepare_settings(FLAGS.num_classes, FLAGS.sample_rate, FLAGS.clip_duration_ms, FLAGS.window_size_ms, FLAGS.window_stride_ms, FLAGS.dct_coefficient_count) runtime_settings = {'clip_stride_ms': FLAGS.clip_stride_ms} wav_data_placeholder = tf.placeholder(tf.string, [], name='wav_data') decoded_sample_data = contrib_audio.decode_wav( wav_data_placeholder, desired_channels=1, desired_samples=model_settings['desired_samples'], name='decoded_sample_data') spectrogram = contrib_audio.audio_spectrogram( decoded_sample_data.audio, window_size=model_settings['window_size_samples'], stride=model_settings['window_stride_samples'], magnitude_squared=True) fingerprint_input = contrib_audio.mfcc( spectrogram, decoded_sample_data.sample_rate, dct_coefficient_count=FLAGS.dct_coefficient_count) fingerprint_frequency_size = model_settings['dct_coefficient_count'] fingerprint_time_size = model_settings['spectrogram_length'] reshaped_input = tf.reshape( fingerprint_input, [-1, fingerprint_time_size, fingerprint_frequency_size, 1], name="model_input") # Init model and load variables model = models.create_model(FLAGS) fw = framework.Framework(sess, model, None, FLAGS, input_tensor=reshaped_input) # Create an output to use for inference logits = tf.nn.softmax(model.get_raw_scores(), name='labels_softmax')
async def run(): async with aiohttp.ClientSession(loop=loop) as session: fw = {} for r in call.REGIONS: fw[r] = framework.Framework(loop, session, r, (20, 1), (100, 120)) fw[r].set_key(api_key) res = [] for r in call.REGIONS: task = loop.create_task( league.get_challenger(fw[r], "RANKED_SOLO_5x5")) res.append(task) task.add_done_callback(process_league) task = loop.create_task(league.get_master(fw[r], "RANKED_SOLO_5x5")) res.append(task) task.add_done_callback(process_league) await asyncio.wait(res, loop=loop, return_when="ALL_COMPLETED")
def __init__(self, conf): self.step = 0 self.max_step = conf['max_step'] self.learn_start = conf['learn_start'] self.train_report_step = conf['train_report_step'] self.evaluate_step = conf['evaluate_step'] self.test_step = conf['test_step'] self.framework = framework.Framework(conf) self.QLearner = QLearner.QLearner(conf) self.max_avg_reward = -1000 self.best_network = None self.training_time = 0 self.testing_time = 0 self.run_test_cnt = 0 self.reward_log = open('../data/reward_log', 'w') self.test_log = open('../data/game_log', 'w') self.detail_log = open('../data/detail_log', 'w')
def main(_): print("Model Architecture: {}".format(FLAGS.model_architecture)) # Adjust some parameters if FLAGS.debug: FLAGS.small_label_set = False print("RUNNING IN DEBUG MODE") FLAGS.num_classes = utils.get_num_classes(FLAGS) X_train, y_train = data_utils.load_dataset_tf(FLAGS, mode="train") X_val, y_val = data_utils.load_dataset_tf(FLAGS, mode="val") # comet_ml experiment logging (https://www.comet.ml/) experiment = Experiment(api_key="J55UNlgtffTDmziKUlszSMW2w", log_code=False) experiment.log_multiple_params(utils.gather_params(FLAGS)) experiment.set_num_of_epocs(FLAGS.epochs) experiment.log_dataset_hash(X_train) tf.logging.set_verbosity(tf.logging.INFO) # Start a new, DEFAULT TensorFlow session. sess = tf.InteractiveSession() utils.set_seeds() # Get deterministic behavior? model = models.create_model(FLAGS) fw = framework.Framework(sess, model, experiment, FLAGS) num_params = int(utils.get_number_of_params()) model_size = num_params * 4 print("\nNumber of trainable parameters: {}".format(num_params)) print("Model is ~ {} bytes out of max 5000000 bytes\n".format(model_size)) experiment.log_parameter("num_params", num_params) experiment.log_parameter("approx_model_size", model_size) fw.optimize(X_train, y_train, X_val, y_val)
#The main entrance into the File system Application #Should contain all the visible workings of Program import framework if __name__ == '__main__': test = framework.Framework() test.showAll()
# moveing drone if speed_forward < 0: dronecontroller.backward(-speed_forward) else: dronecontroller.forward(speed_forward) if speed_rightleft < 0: dronecontroller.left(-speed_rightleft) else: dronecontroller.right(speed_rightleft) if speed_clockwise < 0: dronecontroller.counter_clockwise(-speed_clockwise) else: dronecontroller.clockwise(speed_clockwise) # saving all sended commands to the csv file cmdrecoder.write_csv('cmdout.csv') # Finalization archecker.stop_armcheck() dronecontroller.disconnect() #=================================================================================== # Start up if __name__ == '__main__': _framework = framework.Framework(main) _framework.run()
torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False parser = argparse.ArgumentParser() parser.add_argument('--model_name', type=str, default='Casrel', help='name of the model') parser.add_argument('--lr', type=float, default=1e-5) parser.add_argument('--multi_gpu', type=bool, default=False) parser.add_argument('--dataset', type=str, default='baidu') parser.add_argument('--batch_size', type=int, default=32) parser.add_argument('--max_epoch', type=int, default=300) parser.add_argument('--test_epoch', type=int, default=1) parser.add_argument('--train_prefix', type=str, default='duie_train') parser.add_argument('--dev_prefix', type=str, default='duie_dev') parser.add_argument('--test_prefix', type=str, default='duie_test1') parser.add_argument('--max_len', type=int, default=300) parser.add_argument('--rel_num', type=int, default=53) parser.add_argument('--period', type=int, default=50) parser.add_argument('--debug', type=bool, default=False) args = parser.parse_args() con = config.Config(args) fw = framework.Framework(con) model = {'Casrel': models.Casrel} fw.testall(model[args.model_name])
try: import numpy except ModuleNotFoundError: sys.exit( 'Needs module numpy to work properly. To install, run `python3 -m pip install numpy`' ) pygame.init() import framework import lan # must come after pygame.init() screen = pygame.display.set_mode((800, 800), pygame.RESIZABLE) pygame.display.set_caption('Eros') double_socket = lan.run(screen) try: if double_socket: handler = framework.Framework() handler.run(screen, double_socket) else: lan.run_as_guest(screen) except (TypeError, BrokenPipeError, ConnectionResetError, KeyboardInterrupt): pass
from __future__ import absolute_import from __future__ import print_function from __future__ import division import tensorflow as tf import test.task as task import framework as fw if __name__ == '__main__': tf.flags.DEFINE_integer("print_freq", 100, "Frequency of printing") FLAGS = tf.flags.FLAGS hparams = fw.default_hparams hparams.add_hparam('n_inputs', 2) hparams.add_hparam('with_path_id', False) hparams.add_hparam('query_mode', 'single_query') hparams.add_hparam('learning_mode', 'supervised') hparams.add_hparam('flow_length', 4) maze = task.IntegerMaze() model = fw.Framework(maze) model.train(FLAGS)