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)