def test_parameters_are_not_none(self): self.assertNotEqual(parse_args().addr, None, 'IP адрес не может быть None или Null') self.assertNotEqual(parse_args().port, None, 'Номер порта не может быть None или Null') self.assertNotEqual(parse_args().user, None, 'Имя пользователя не может быть None или Null')
def _input_validator(args): try: parse_args(args) except SystemExit as e: assert isinstance(e.__context__, argparse.ArgumentError) assert 'Value has to be greater than 0' in str(e.__context__) else: raise ValueError("Exception not raised")
def test_single_arg(self): args1 = get_default_args() args1[arg.JOIN] = True args2 = parse_args('join') self.assertEqual(args1, args2) args1 = get_default_args() args1[arg.SCALE_CORNER] = 3 args2 = parse_args('scalecorner=3') self.assertEqual(args1, args2)
def test_six_files(self): filenames = [self.__random_filename() for _ in range(6)] found_filenames = [] # Make sure argparse checks all generated files def mock_open(in_filename, in_mode, *args, **kwargs): self.assertIn(in_filename, filenames) self.assertEqual(in_mode, "r") found_filenames.append(in_filename) return unittest.mock.MagicMock() main.argparse.open = mock_open main.parse_args(filenames) self.assertEqual(found_filenames, filenames)
def grid_search(config: dict): args = parse_args() results = {} for d in config["dataset"]: args.dataset = d best_acc, err_bd = 0., 0. best_args = vars(args) for arch in config["arch"]: args.architecture = arch for hidden in config["hidden"]: args.hid_dim = hidden for pool_ratio in config["pool_ratio"]: args.pool_ratio = pool_ratio for lr in config["lr"]: args.lr = lr for weight_decay in config["weight_decay"]: args.weight_decay = weight_decay acc, bd = run_experiments(args) if acc > best_acc: best_acc = acc err_bd = bd best_args = deepcopy(vars(args)) args.output_path = "./output" if not os.path.exists(args.output_path): os.makedirs(args.output_path) args.output_path = "./output/{}.log".format(d) result = { "params": best_args, "result": "{:.4f}({:.4f})".format(best_acc, err_bd) } with open(args.output_path, "w") as f: json.dump(result, f, sort_keys=True, indent=4)
def setup(opts): args = parse_args() args.dataset = 'portrait' gan = UGATIT(sess, args) gan.build_model() gan.load_from_latest(opts['checkpoint']) return gan
def setup(): args = parse_args() if args.cfg_file is not None: cfg_from_file(args.cfg_file) data = importlib.import_module('{}_data'.format(cfg.DATASET_NAME)) # Configure CUDA if args.manualSeed is None: args.manualSeed = random.randint(1, 10000) random.seed(args.manualSeed) torch.manual_seed(args.manualSeed) if cfg.CUDA: torch.cuda.manual_seed_all(args.manualSeed) num_gpu = len(cfg.GPU_ID.split(',')) # Set output path output_dir = os.path.join(args.output_dir, '%s_%s/' % (cfg.DATASET_NAME, cfg.CONFIG_NAME)) test_sample_save_dir = output_dir + 'Test/' if not os.path.exists(test_sample_save_dir): os.makedirs(test_sample_save_dir) args.data = data args.num_gpu = num_gpu args.output_dir = output_dir args.test_sample_save_dir = test_sample_save_dir return args
def test_exception_is_not_raised_if_all_required_flags_are_provided( self, stderr): arguments = parse_args(['localhost', '1337', 'localhost', '1338']) self.assertEqual(arguments.hostname, 'localhost') self.assertEqual(arguments.port, 1337) self.assertEqual(getattr(arguments, 'app-port'), 1338) self.assertEqual(getattr(arguments, 'app-hostname'), 'localhost')
def test_argument_parser(): test_player1 = random.choice(characters) test_player2 = random.choice(characters) parser = parse_args( ["--first", test_player1, "--second", test_player2, "--trials", "100"]) assert parser.first == test_player1 assert parser.second == test_player2 assert parser.trials == 100
def setup(opts): args = parse_args() args.phase = 'test' args.img_size = 256 gan = UGATIT(sess, args) gan.build_model() gan.load_from_latest(opts['checkpoint']) return gan
def test_ignore_oval_licence(self): licence = RaceType.Oval.value self.params += ['--ignore', str(licence)] parser = main.parse_args(self.params) ignore_list = parser.ignore assert_true(licence in ignore_list) assert_equal(len(ignore_list), 1)
def test_parse_args_options(self): argv = ['-t', 'test_table', '-d', 'sqlite://', '-b', '120', '-a', '-v', 'TestData'] args = main.parse_args(argv) self.assertEqual(args.fname, 'TestData') self.assertEqual(args.table_name, 'test_table') self.assertEqual(args.database, 'sqlite://') self.assertEqual(args.batch, 120) self.assertTrue(args.verbose) self.assertTrue(args.append)
def test_parse_args_defaults(self): argv = ['TestData'] args = main.parse_args(argv) self.assertEqual(args.fname, 'TestData') self.assertIsNone(args.table_name) self.assertEqual(args.database, 'sqlite:///TestData.db') self.assertEqual(args.batch, 120000) self.assertFalse(args.verbose) self.assertFalse(args.append)
def test_basic_call(self): with NamedTemporaryFile(delete=False) as fw: for i in range(10000): p = Popen(['radamsa'], stdout=PIPE, stdin=PIPE, stderr=PIPE) try: test_args = p.communicate(input='h_pages=2'.encode())[0] except: pass else: try: with self.assertRaises(ValueError): parse_args(test_args.decode()) except AssertionError: fw.write(test_args + '\n'.encode()) finally: p.terminate() call('sort -u {}'.format(fw.name), shell=True) unlink(fw.name) ret = input('Looking good? [N, y] ') self.assertEqual(ret.lower().strip(), 'y')
def do(cmd_args): args = parse_args(cmd_args) rewards = run(args) avg_reward = np.average(rewards) std_reward = np.std(rewards) results = { "args": cmd_args, "avg_reward": avg_reward, "std_reward": std_reward, "rewards": rewards, } return results
def test_wrong_keyword(self): with self.assertRaises(ValueError): parse_args('wfawr') with self.assertRaises(ValueError): parse_args('joi n') with self.assertRaises(ValueError): parse_args('scale=20.2, widht=10')
def test_parse_args_options(self): argv = [ '-t', 'test_table', '-d', 'sqlite://', '-b', '120', '-a', '-v', 'TestData' ] args = main.parse_args(argv) self.assertEqual(args.fname, 'TestData') self.assertEqual(args.table_name, 'test_table') self.assertEqual(args.database, 'sqlite://') self.assertEqual(args.batch, 120) self.assertTrue(args.verbose) self.assertTrue(args.append)
def test_ignore_dirt_licences(self): self.params += [ '--ignore', str(RaceType.Dirt_Oval.value), str(RaceType.Dirt_Road.value) ] parser = main.parse_args(self.params) ignore_list = parser.ignore assert_list_equal([RaceType.Dirt_Oval.value, RaceType.Dirt_Road.value], ignore_list) assert_equal(len(ignore_list), 2)
def test_trans_coverage(self): args = main.parse_args(["--dir=tests"]) ext = tuple(args.ext.split()) e_count, n_count = main.trans_coverage(-1, args, "tests", ext) print("test dir: ", e_count, n_count) self.assertNotEqual(0, e_count) self.assertNotEqual(0, n_count) # Generate/update sample file # `python main.py --dir tests > sample.md` with open("sample.md", "r") as sample: s1 = sample.read().splitlines() s2 = main.print_out(args).splitlines() self.assertEqual(s1, s2)
def test_all_arguments(self): args1 = { arg.H_PAGES: 3, arg.V_PAGES: 2, arg.NORTH: 4, arg.KEYPAD: 2, arg.NX: 4, arg.NY: 6, arg.TITLE: 'AO QESHM', arg.SCALE_CORNER: 1, arg.SCALE: 2.0, arg.JOIN: True, arg.WIDTH: 9.0 } args2 = parse_args( 'h_pages=3, v_pages=2, north=4, nx=4, ny=6, title=AO QESHM, scale=2,' + 'scalecorner=1, join, width = 9.0, keypad=2') self.assertEqual(args1, args2)
def __init__(self, config, env_creator): self.config = config self.config.update(config) self.args = parse_args([ "--multi-step={}".format(self.config["n_step"]), "--discount={}".format(self.config["gamma"]), "--lr={}".format(self.config["lr"]), "--game={}".format(self.config["env"]), ]) self.env = wrap_deepmind(env_creator(self.config["env_config"]), frame_stack=True, scale=True) self.action_space = self.env.action_space.n self.agent = Agent(self.args, self.action_space) self.state = to_rainbow(self.env.reset()) self.local_timestep = 0 self.episode_rewards = [0.0] self.episode_lengths = [0.0] self.lock = Lock()
def init_model(self): args = parse_args() if args is None: exit() args.phase = 'test' args.dataset = 'selfie2anime' # args.light = 'True' args.img_size = 256 # open session sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) gan = UGATIT(sess, args) # build graph gan.build_model() # show network architecture # show_all_variables() gan.init_model(sess) return gan, sess
def indicator_data_save(): from dataset.datasets import LayoutDataset # config cfg file args = parse_args() if args.cfg_file is not None: cfg_from_file(args.cfg_file) indicator_path = "/home/zhoujiaqiu/Code/GAN/LayoutGenerator/dataset/data" \ "/indicator_train_data/constraint_inter" dataset = LayoutDataset(cfg.DATA_DIR, cfg.INDICATOR_DIR, train_set=True) convert_layout = ConversionLayout() constraint_rules = [1, 2, 3, 4, 5] for n in range(len(dataset.pair_room_datas)): pair_data, init_contour, indicator_hull = dataset.pair_room_datas[n], dataset.pair_init_contours[n], \ dataset.indicator_hull[n] indicator_values = np.zeros((len(pair_data), 1)) for i in range(len(pair_data)): # data: [1, 2500, 2, 4, 3] init_contour: [2500, 2, n, 3] # indicator_hull: [1, 2500, 2, 5, n, 2] layout1_room, layout2_room = pair_data[i][0], pair_data[i][1] layout1_init_contour, layout2_init_contour = init_contour[i][ 0], init_contour[i][1] layout1_hull, layout2_hull = indicator_hull[i][0], indicator_hull[ i][1] indicator_value = indicator.calculate_score( layout1_init_contour, layout1_hull, layout2_hull, constraint_rules) indicator_values[i] = indicator_value print( "on {} layouts, the {} indicator_value save finished!".format( n, i)) # /****** visualization ******/ # from trainer.trainer_evaluator import visualization # save_path = "/home/zhoujiaqiu/Code/GAN/ours_layout_generator/dataset/visualization/{}.png".format(n) # visual_hull = [layout1_hull, layout2_hull] # visualization(visual_hull, [indicator_value, indicator_value], save_path) save_indicator_path = os.path.join( indicator_path, "layout_{}_indicator_value.npy".format(n)) np.save(save_indicator_path, indicator_values)
def serve(args=None): if args is None: args = sys.argv[1:] args = parse_args(args) env = Environment(args) env.GetStockDataVecFN("SomeData.csv", False) env.check_data_integrity4prediction_at("2018-09-03 10:05:00") agent = Agent( env.get_state_size(), env.get_action_size(), 2.5e-4 #lr , 1e-2 #env.tau , args.dueling, args.hidden_dim) agent.loadModel(r"D:\PycharmProjects\DDQN_tester\model_1") from wsgiref.simple_server import make_server wsgi_app = WsgiApplication(application) server = make_server('0.0.0.0', 8000, wsgi_app) server.serve_forever()
def main(): args = parse_args() t0 = time.time() if not os.path.exists(args.save_directory): os.makedirs(args.save_directory) LOG_PATH = os.path.join(args.save_directory, 'log') with open(LOG_PATH, 'w+') as ouf: pass print("Loading File IDs and Y Data") train_ids, train_ys = load_fid_and_y_data('train') dev_ids, dev_ys = load_fid_and_y_data('dev') test_ids, test_ys = load_fid_and_y_data('test') t1 = time.time() print_log('%.2f Seconds' % (t1 - t0), LOG_PATH) print("Building Charset") charset = build_charset(np.concatenate((train_ys, dev_ys, test_ys), axis=0)) charmap = make_charmap(charset) # {string: int} charcount = len(charset) t1 = time.time() print_log('%.2f Seconds' % (t1 - t0), LOG_PATH) print("Mapping Characters") testchars = map_characters(test_ys, charmap) print("Building Loader") test_loader = make_loader(test_ids, testchars, args, shuffle=False, batch_size=args.batch_size) if 'transcript' in args.test_mode or 'perp' in args.test_mode: print("Building Model") model = Seq2SeqModel(args, vocab_size=charcount) CKPT_PATH = os.path.join(args.save_directory, 'model.ckpt') if torch.cuda.is_available(): model.load_state_dict(torch.load(CKPT_PATH)) else: gpu_dict = torch.load(CKPT_PATH, map_location=lambda storage, loc: storage) cpu_model_dict = {} for key, val in gpu_dict.items(): cpu_model_dict[key] = val.cpu() model.load_state_dict(cpu_model_dict) print("Loaded Checkpoint") if torch.cuda.is_available(): model = model.cuda(args.cuda) model.eval() transcript_log_path = os.path.join(args.save_directory, 'transcript_log.txt') csv_path = os.path.join(args.save_directory, 'submission.csv') if 'transcript' in args.test_mode: print('generating transcripts') with open(transcript_log_path, 'w+') as ouf: pass if not os.path.exists(csv_path): transcripts = write_transcripts(path=csv_path, args=args, model=model, loader=test_loader, charset=charset, log_path=transcript_log_path) else: transcripts = [] with open(csv_path, 'r') as csvfile: raw_csv = csv.reader(csvfile) for row in raw_csv: with open(transcript_log_path, 'a') as ouf: ouf.write('%s\n' % row[1]) transcripts.append(row[1]) t1 = time.time() print("Finshed Writing Transcripts") print('%.2f Seconds' % (t1 - t0)) if 'cer' in args.test_mode: print('calculating cer values') cer_log_path = os.path.join(args.save_directory, 'cer_log.txt') with open(cer_log_path, 'w+') as ouf: pass transcripts = [] with open(csv_path, 'r') as csvfile: raw_csv = csv.reader(csvfile) for row in raw_csv: transcripts.append(row[1]) transcripts = [l.strip() for l in transcripts] cer_path = os.path.join(args.save_directory, 'test_cer.npy') dist_path = os.path.join(args.save_directory, 'test_dist.npy') norm_dists, dists = cer_from_transcripts(transcripts, test_ys, cer_log_path) np.save(cer_path, norm_dists) np.save(dist_path, dists) print('avg CER:', np.mean(norm_dists)) if 'perp' in args.test_mode: print('calculating perp values') PERP_LOG_PATH = os.path.join(args.save_directory, 'perp_log.txt') with open(PERP_LOG_PATH, 'w+') as ouf: pass perp_path = os.path.join(args.save_directory, 'test_perp.npy') all_perps = perplexities_from_x(model, test_loader) np.save(perp_path, all_perps)
def test_parameters_are_not_none(self): self.assertNotEqual(parse_args().a, None, 'IP адрес не может быть None или Null') self.assertNotEqual(parse_args().p, None, 'Номер порта не может быть None или Null')
def test_number_parameters(self): self.assertEqual(len(parse_args().__dict__), 2, 'Нет необходимых трёх параметров для запуска') pass
def test_parse_args_short_arg(self): args = main.parse_args(["-p", password]) self.assertEqual(args.password, password)
def test_parse_args_with_invalid_args(self): with self.assertRaises(SystemExit): main.parse_args(["-x", "y"])
def test_parse_args_long_arg(self): args = main.parse_args(["--password", password]) self.assertEqual(args.password, password)
def test_empty(self): self.assertEqual(parse_args(''), get_default_args()) self.assertEqual(parse_args(' '), get_default_args()) self.assertEqual(parse_args('\n'), get_default_args())
def test_parse_add(self): args = main.parse_args(['add', 'tom', '123-456-7890', '-b', 'phonebook']) self.assertEqual(vars(args), {'func':main.add, 'name':'tom', 'phonebook':['phonebook'], 'number':'123-456-7890'}) self.assertRaises(argparse.ArgumentError, main.parse_args, ['add', 'tom', '123123-456-7890', '-b', 'phonebook'])