def parse_stonks(content: str): # stonks and stinks (aka badstonks) lines = content.splitlines() args = parse_arguments(content) stonks = { 'cap_sep': [], 'head': '', 'flip': args['flip'], # horizontal flip 'bad': False, 'custom_text': '' } for line in lines: # remove zero-width spaces and leading/trailing whitespace naked_line = line.replace('\u200b', '').strip() # caption and sep (can only be added *before* meme body) cap = parse_caption(naked_line) if cap is not None: stonks['cap_sep'].append(('cap', cap)) elif is_sep(naked_line): stonks['cap_sep'].append(('sep', '')) for idx, emj in enumerate([':stonks: ', ':badstonks: ']): if (naked_line.startswith(emj) and naked_line.replace(emj, '', 1).strip()): words = naked_line.replace(emj, '', 1).split() if words and is_in_emoji_form(words[0]): stonks['head'] = words[0].strip(':') stonks['bad'] = True if idx == 1 else False if len(words) > 1: # custom text present stonks['custom_text'] = ' '.join(words[1:]) return (stonks, '') return (None, None)
def test_parser_is_module_allowed(): cmt.ARGS = args.parse_arguments(['url', 'cpu']) assert args.is_module_allowed_in_args('url') is True assert args.is_module_allowed_in_args('cpu') is True assert args.is_module_allowed_in_args('swap') is False
def main(): # get hyper parameters args = parse_arguments() # load data print("\nLoading data...") TEXT = data.Field(lower=True, batch_first=True) LABEL = data.Field(sequential=False) train_iter, val_iter = imdb(TEXT, LABEL, args.batch_size) # update args args.n_vocab = n_vocab = len(TEXT.vocab) args.n_classes = n_classes = len(LABEL.vocab) - 1 args.cuda = torch.cuda.is_available() args.kernel_sizes = [int(k) for k in args.kernel_sizes.split(',')] args.save_dir = os.path.join( args.save_dir, datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) # print args print("\nParameters:") for attr, value in sorted(args.__dict__.items()): print("\t{}={}".format(attr.upper(), value)) # initialize/load the model if args.snapshot is None: classifier = classifiers[args.model] classifier = classifier(args, n_vocab, args.embed_dim, n_classes, args.dropout) else: print('\nLoading model from [%s]...' % args.snapshot) try: classifier = torch.load(args.snapshot) except: print("Sorry, This snapshot doesn't exist.") exit() if args.cuda: classifier = classifier.cuda() # train, test, or predict if args.predict is not None: label = predict(classifier, args.predict, TEXT, LABEL) print('\n[Text] {}[Label] {}\n'.format(args.predict, label)) elif args.test: try: evaluate(classifier, test_iter, args) except Exception as e: print("\nSorry. The test dataset doesn't exist.\n") else: print() train(classifier, train_iter, val_iter, args)
def run(): args = parse_arguments() print(args) env = gym.make(args.environment) env.seed(args.seed or 0) reward = 0 done = False agent = None if args.model == 'obs-policy': agent = ObsPolicyModel(args.convs or 1, 16, env.observation_space.shape, env.action_space.n, args.layers or 1, args.neurons or 32) print('observ_space:', env.observation_space.shape) print('action_space:', env.action_space.n) agent.build() if agent == None: raise('You have chosen an unimplented model/agent.') for i in range(args.episode_count): total_reward = 0 print(f'Episode #{str(i)} reward: {total_reward}') obs = env.reset() agent.reset() render_episode = i % args.render == 0 if args.render else False while True: if render_episode: env.render() action = agent.act(obs, reward, done) obs, reward, done, _ = env.step(action) total_reward += reward if done: agent.act(obs, reward, done) break # Close the env and write monitor result info to disk env.close()
# raise Exception("Timed out!") print("Timed out ! (max_execution_time)") sys.exit() # ------------ # Main entry # ------------ if __name__ == "__main__": if not sys.version_info >= (3, 6): print("Should use Python >= 3.6") sys.exit() cmt.ARGS = args.parse_arguments(sys.argv[1:]) if cmt.ARGS["version"]: print(cmt.VERSION) sys.exit() err = args.get_invalid_modules_in_args() if len(err) > 0: print("ERR - Unknow module(s) : " + ','.join(err)) sys.exit() # conf.yml, conf.d/*.yml cmt.CONF = conf.load_conf() # if cron mode, introduce a small uase (offset) tô spread the load on metrology servers if cmt.ARGS['cron']:
def test_parser_is_module_list_valid_in_args(): cmt.ARGS = args.parse_arguments(['url', 'cpu']) assert args.is_module_list_valid_in_args() is True
def test_parser_help(): with pytest.raises(SystemExit): r = args.parse_arguments(['-h'])
def test_parser_cron(): r = args.parse_arguments(['--cron']) assert r['cron'] is True
def test_parser_empty(): r = args.parse_arguments([]) assert r['cron'] is False assert r['short'] is False assert r['persist'] is False
# Level 2: An exponential-time naive recursive implementation which counts # sequences without generating them explicitly. from neighbors import neighbors def count_sequences(start_position, num_hops): if num_hops == 0: return 1 num_sequences = 0 for position in neighbors(start_position): num_sequences += count_sequences(position, num_hops - 1) return num_sequences if __name__ == '__main__': import args a = args.parse_arguments() print(count_sequences(a.start_position, a.num_hops))
"decoder_start_token_id": target_tokenizer.cls_token_id, "num_beams": args.num_beams, "num_return_sequences": args.num_outputs, "no_repeat_ngram_size": 0 } if args.type_forcing: generate_args["type_forcing_vocab"] = type_forcing_vocab outputs = bert2arsenal.generate(**generate_args) # apparently batch instances and return sequences per instance are stacked along a single dimension for j in range(batch_size): input = [t for t in batch["input_ids"][j] if t != 0] true_seq = [t for t in batch['labels'][j] if t != -100] outfile.write(f"{input}\t{true_seq}") for k in range(j * args.num_outputs, (j + 1) * args.num_outputs): pred_seq = [t for t in outputs[k].tolist() if t != 0] outfile.write(f"\t{pred_seq}") outfile.write("\n") outfile.flush() outfile.close() # if __name__ == "__main__": args = parse_arguments(sys.argv[1:]) print(tabulate(vars(args).items(), headers={"parameter", "value"})) generate_predictions(args)
inform("Exception during stopping monitor %s " % e) finally: inform("BYEEE!") atexit.register(cleanup) if __name__ == "__main__": global monitor global DIR global flush_frequency monitor = None signals_to_handle = [signal.SIGINT,signal.SIGHUP,signal.SIGQUIT,signal.SIGABRT,signal.SIGALRM] args = parse_arguments() DIR = "" flush_frequency = args.flush monitor = FileTaskMonitor(workers=args.max_proc) def signal_handler(signal, frame): inform( "Handling signal %s %s"%(signal,frame )) # monitor.stop() sys.exit(0) DIR = args.input_dir for os_signal in signals_to_handle: signal.signal(os_signal, signal_handler)
#!/usr/bin/python3 from args import parse_arguments import controller if __name__ == '__main__': args = parse_arguments() controller.run(exchange_after=args.exchange, generations=args.generations, cities=args.cities, population_size=args.chromosomes, elite_size=args.elite, mutation_probability=args.mprobability, independent_populations=args.populations, number_workers=args.workers, verbose=args.verbose, latex=args.latex)
from args import parse_arguments import multiprocessing import os import webbrowser import time params = parse_arguments() if params.num_workers == -1: num_workers = multiprocessing.cpu_count( ) # Set workers to number of available CPU threads else: num_workers = params.num_workers launcher = 'tensorboard --logdir=' for worker in range(num_workers): launcher += 'worker_' + str(worker) + ':train_' + str(worker) + '/,' if __name__ == '__main__': os.system(launcher) time.sleep(3) webbrowser.open('http://localhost:6006', new=2)
def prepare(toot: str, emojis={}, instance='', saveto='') -> tuple: # return meme type and parsed info if toot is meme # else, return 'not a meme' and None. blessed = uncurse(toot) if not blessed.strip(): return ('empty', None, None) arguments = parse_arguments(blessed) # overall priority: # font > mono > lang # arguments here are filled with default values in args.py # mono overrides lang (if mono is present, the elif will not be entered) if arguments['mono']: font = MONO elif arguments['lang'] in LANGS: font = LANGS[arguments['lang']] else: return ('language not supported', None, None) stroke = False if arguments['font'] in FONTS: # font overrides mono and lang font = FONTS[arguments['font']] if arguments['font'] == 'impact': stroke = True # render text in its stroke (outline) elif arguments['font'] == 'unchanged': # default value in args.py pass else: return ('font not supported', None, None) drakes, desc = parse_drake(blessed) if drakes: # is drake meme (or at least a portion thereof) return ('Drake', { 'drakes': drakes, 'emojis': emojis, 'font': font, 'stroke': stroke, 'instance': instance, 'saveto': saveto }, desc) # return meme type and parsed info # uh oh, is not drake brains, desc = parse_brainsize(blessed) if brains: # is brain size meme return ('Brain Size', { 'brains': brains, 'emojis': emojis, 'font': font, 'stroke': stroke, 'instance': instance, 'saveto': saveto }, desc) stonks, desc = parse_stonks(blessed) if stonks: # is stonks meme return ('Stonks', { 'stonks': stonks, 'emojis': emojis, 'font': font, 'stroke': stroke, 'instance': instance, 'saveto': saveto }, desc) woman_yelling, desc = parse_woman_yelling(blessed) if woman_yelling: # is woman yelling meme return ('Woman Yelling', { 'entities': woman_yelling, 'emojis': emojis, 'font': font, 'stroke': stroke, 'instance': instance, 'saveto': saveto }, desc) # NOTE TO SELF: do not forget to add proxy to def memethesis() # when adding a new meme type return ('not a meme', None, None)