def answer(topic=None): """ Main rendering function, it processes incoming weather queries. Depending on user agent it returns output in HTML or ANSI format. Incoming data: request.args request.headers request.remote_addr request.referrer request.query_string """ user_agent = request.headers.get('User-Agent', '').lower() html_needed = is_html_needed(user_agent) options = parse_args(request.args) if topic in ['apple-touch-icon-precomposed.png', 'apple-touch-icon.png', 'apple-touch-icon-120x120-precomposed.png']: return '' request_id = request.cookies.get('id') if topic is not None and topic.lstrip('/') == ':last': if request_id: topic = last_query(request_id) else: return "ERROR: you have to set id for your requests to use /:last\n" else: if request_id: save_query(request_id, topic) if request.method == 'POST': process_post_request(request, html_needed) if html_needed: return redirect("/") return "OK\n" if 'topic' in request.args: return redirect("/%s" % request.args.get('topic')) if topic is None: topic = ":firstpage" if topic.startswith(':shell-x/'): return _proxy() #return requests.get('http://127.0.0.1:3000'+topic[8:]).text ip_address = get_request_ip(request) if '+' in topic: not_allowed = LIMITS.check_ip(ip_address) if not_allowed: return "429 %s\n" % not_allowed, 429 html_is_needed = is_html_needed(user_agent) result, found = cheat_wrapper(topic, request_options=options, html=html_is_needed) if 'Please come back in several hours' in result and html_is_needed: return MALFORMED_RESPONSE_HTML_PAGE log_query(ip_address, found, topic, user_agent) return result
def main(): # parse the options opts = parse_args() # create the dataloaders dataloader = {'train': create_dataloader('train_valid' if opts.no_validation else 'train', opts), 'valid': create_dataloader('valid', opts)} # create the model model = Prover(opts) model.to(opts.device) # crete the optimizer optimizer = torch.optim.RMSprop(model.parameters(), lr=opts.learning_rate, momentum=opts.momentum, weight_decay=opts.l2) if opts.no_validation: scheduler = StepLR(optimizer, step_size=opts.lr_reduce_steps, gamma=0.1) else: scheduler = ReduceLROnPlateau(optimizer, patience=opts.lr_reduce_patience, verbose=True) # load the checkpoint start_epoch = 0 if opts.resume != None: log('loading model checkpoint from %s..' % opts.resume) if opts.device.type == 'cpu': checkpoint = torch.load(opts.resume, map_location='cpu') else: checkpoint = torch.load(opts.resume) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) start_epoch = checkpoint['n_epoch'] + 1 model.to(opts.device) agent = Agent(model, optimizer, dataloader, opts) best_acc = -1. for n_epoch in range(start_epoch, start_epoch + opts.num_epochs): log('EPOCH #%d' % n_epoch) # training loss_train = agent.train(n_epoch) # save the model checkpoint if n_epoch % opts.save_model_epochs == 0: agent.save(n_epoch, opts.checkpoint_dir) # validation if not opts.no_validation: loss_valid = agent.valid(n_epoch) # reduce the learning rate if opts.no_validation: scheduler.step() else: scheduler.step(loss_valid)
def main(sys_argv: List[str] = None): if sys_argv is None: sys_argv = sys.argv[1:] conf = parse_args(sys_argv) args = DotMap(conf, _dynamic=False) if args.meta == 'training': training_main(args) else: raise ValueError
def answer(topic=None): """ Main rendering function, it processes incoming weather queries. Depending on user agent it returns output in HTML or ANSI format. Incoming data: request.args request.headers request.remote_addr request.referrer request.query_string """ user_agent = request.headers.get('User-Agent', '').lower() html_needed = is_html_needed(user_agent) options = parse_args(request.args) if topic in ['apple-touch-icon-precomposed.png', 'apple-touch-icon.png', 'apple-touch-icon-120x120-precomposed.png']: return '' request_id = request.cookies.get('id') if topic is not None and topic.lstrip('/') == ':last': if request_id: topic = last_query(request_id) else: return "ERROR: you have to set id for your requests to use /:last\n" else: if request_id: save_query(request_id, topic) if request.method == 'POST': process_post_request(request, html_needed) if html_needed: return redirect("/") return "OK\n" if 'topic' in request.args: return redirect("/%s" % request.args.get('topic')) if topic is None: topic = ":firstpage" if topic.startswith(':shell-x/'): return _proxy() #return requests.get('http://127.0.0.1:3000'+topic[8:]).text ip_address = get_request_ip(request) if '+' in topic: not_allowed = LIMITS.check_ip(ip_address) if not_allowed: return "429 %s\n" % not_allowed, 429 result, found = cheat_wrapper(topic, request_options=options, html=is_html_needed(user_agent)) log_query(ip_address, found, topic, user_agent) return result
def main(img_path): options = parse_args() model = Model(options) model.load_state_dict( torch.load('checkpoint.pth', map_location=torch.device('cpu'))) corner_pred, icon_pred, room_pred = model( torch.tensor(load_image(img_path))) corner_heatmaps = corner_pred[0].detach().cpu().numpy() icon_heatmaps = torch.nn.functional.softmax(icon_pred[0], dim=-1).detach().cpu().numpy() room_heatmaps = torch.nn.functional.softmax(room_pred[0], dim=-1).detach().cpu().numpy() wallCornerHeatmaps = corner_heatmaps[:, :, :NUM_WALL_CORNERS] doorCornerHeatmaps = corner_heatmaps[:, :, NUM_WALL_CORNERS:NUM_WALL_CORNERS + 4] iconCornerHeatmaps = corner_heatmaps[:, :, -4:] maps = { 'original': cv2.imread(img_path), 'corner_heatmaps': corner_heatmaps.max(-1), 'icon_heatmaps': icon_heatmaps.max(-1), 'room_heatmaps': room_heatmaps.max(-1), 'corner_pred': np.squeeze(corner_pred.max(-1)[1].detach().cpu().numpy()), 'icon_pred': np.squeeze(icon_pred.max(-1)[1].detach().cpu().numpy()), 'room_pred': np.squeeze(room_pred.max(-1)[1].detach().cpu().numpy()), 'wallCornerHeatmaps': wallCornerHeatmaps.max(-1), 'doorCornerHeatmaps': doorCornerHeatmaps.max(-1), 'iconCornerHeatmaps': iconCornerHeatmaps.max(-1), } np_print(maps) plot_images(maps) reconstructFloorplan(wallCornerHeatmaps, doorCornerHeatmaps, iconCornerHeatmaps, icon_heatmaps, room_heatmaps, output_prefix='output-', densityImage=None, gt_dict=None, gt=False, gap=-1, distanceThreshold=-1, lengthThreshold=-1, debug_prefix='test', heatmapValueThresholdWall=None, heatmapValueThresholdDoor=None, heatmapValueThresholdIcon=None, enableAugmentation=True)
def answer(topic=None): """ Main rendering function, it processes incoming weather queries. Depending on user agent it returns output in HTML or ANSI format. Incoming data: request.args request.headers request.remote_addr request.referrer request.query_string """ user_agent = request.headers.get('User-Agent', '').lower() html_needed = is_html_needed(user_agent) options = parse_args(request.args) request_id = request.cookies.get('id') if topic is not None and topic.lstrip('/') == ':last': if request_id: topic = last_query(request_id) else: return "ERROR: you have to set id for your requests to use /:last\n" else: if request_id: save_query(request_id, topic) if request.method == 'POST': process_post_request(request, html_needed) if html_needed: return redirect("/") return "OK\n" if 'topic' in request.args: return redirect("/%s" % request.args.get('topic')) if topic is None: topic = ":firstpage" ip_address = get_request_ip(request) if '+' in topic: not_allowed = LIMITS.check_ip(ip_address) if not_allowed: return "429 %s\n" % not_allowed, 429 result, found = cheat_wrapper(topic, request_options=options, html=is_html_needed(user_agent)) log_query(ip_address, found, topic, user_agent) return result
def main(args=None): # parse args opts = parse_args(args) # analyze result = analyze(opts) if opts.func.__name__ == 'plot': # result = pyplot if opts.output: result.savefig(opts.output) else: try: result.show() except KeyboardInterrupt: exit(0)
def parse_cmdline(args): """ Parses command line arguments and returns query and request_options """ if not args: show_usage() sys.exit(0) query_string = " ".join(args) parsed = urlparse.urlparse("https://srv:0/%s" % query_string) request_options = options.parse_args( urlparse.parse_qs(parsed.query, keep_blank_values=True)) query = parsed.path.lstrip("/") if not query: query = ":firstpage" return query, request_options
def config_init(): parser = argparse.ArgumentParser(conflict_handler='resolve') # add Lightning parse parser = pl.Trainer.add_argparse_args(parser) # add common parse parser = parse_args(parser) # add model specific parser parser = LightningSystem.add_model_specific_args(parser) config = parser.parse_args() if config.seed >= 0: utils.set_seed(config.seed) config.model_name = config.model_name + config.suffix save_path = f"./ckpt/{config.model_name}/" config.save_path = save_path if config.test is False: os.makedirs(config.save_path, exist_ok=True) config.log_path = os.path.join(config.log_path, config.model_name + ".txt") config.gt_path = os.path.join('data', config.dataset_name, 'gt.json') return config
"is_synthetic", "tactic_actions", "tactic_str", ] data_batch = {key: [] for key in fields} for example in batch: for key, value in example.items(): if key not in fields: continue data_batch[key].append(value) return data_batch ds = ProofStepsData(split, opts) return DataLoader( ds, opts.batchsize, shuffle=split.startswith("train"), collate_fn=merge, num_workers=opts.num_workers, ) if __name__ == "__main__": opts = parse_args() loader = create_dataloader("train", opts) bar = ProgressBar(max_value=len(loader)) for i, data_batch in enumerate(loader): if i == 0: print(data_batch) bar.update(i)
def main(): args = parse_args() dataloader_train = create_dataloader(args.train_split, True, args) dataloader_valid = create_dataloader('valid', True, args) dataloader_test = create_dataloader('test', True, args) print('%d batches of training examples' % len(dataloader_train)) print('%d batches of validation examples' % len(dataloader_valid)) print('%d batches of testing examples' % len(dataloader_test)) phrase_encoder = RecurrentPhraseEncoder(300, 300) if args.model == 'drnet': model = DRNet(phrase_encoder, args.feature_dim, args.pretrained) elif args.model == 'vtranse': model = VtransE(phrase_encoder, args.visual_feature_size, args.predicate_embedding_dim) elif args.model == 'vipcnn': model = VipCNN(roi_size=args.roi_size, backbone=args.backbone) else: model = PPRFCN(backbone=args.backbone) model.cuda() print(model) criterion = nn.BCEWithLogitsLoss() criterion.cuda() optimizer = torch.optim.RMSprop([p for p in model.parameters() if p.requires_grad], lr=args.learning_rate, momentum=args.momentum, weight_decay=args.l2) if args.train_split == 'train': scheduler = ReduceLROnPlateau(optimizer, patience=4, verbose=True) else: scheduler = StepLR(optimizer, step_size=args.patience, gamma=0.1) start_epoch = 0 if args.resume != None: print(' => loading model checkpoint from %s..' % args.resume) checkpoint = torch.load(args.resume) model.load_state_dict(checkpoint['state_dict']) model.cuda() optimizer.load_state_dict(checkpoint['optimizer']) start_epoch = checkpoint['epoch'] best_acc = -1. for epoch in range(start_epoch, start_epoch + args.n_epochs): print('epoch #%d' % epoch) print('training..') loss, acc = train(model, criterion, optimizer, dataloader_train, epoch, args) print('\n\ttraining loss = %.4f' % loss) print('\ttraining accuracy = %.3f' % acc) if args.train_split != 'train_valid': print('validating..') loss, accs = test('valid', model, criterion, dataloader_valid, epoch, args) print('\n\tvalidation loss = %.4f' % loss) print('\tvalidation accuracy = %.3f' % accs['overall']) for predi in accs: if predi != 'overall': print('\t\t%s: %.3f' % (predi, accs[predi])) checkpoint_filename = os.path.join(args.log_dir, 'checkpoints/model_%02d.pth' % epoch) model.cpu() torch.save({'epoch': epoch + 1, 'args': args, 'state_dict': model.state_dict(), 'accuracy': acc, 'optimizer' : optimizer.state_dict(), }, checkpoint_filename) model.cuda() if args.train_split != 'train_valid' and best_acc < acc: best_acc = acc shutil.copyfile(checkpoint_filename, os.path.join(args.log_dir, 'checkpoints/model_best.pth')) shutil.copyfile(os.path.join(args.log_dir, 'predictions/pred_%02d.pickle' % epoch), os.path.join(args.log_dir, 'predictions/pred_best.pickle')) if args.train_split == 'train': scheduler.step(loss) else: scheduler.step() print('testing..') loss, accs = test('test', model, criterion, dataloader_test, None, args) print('\n\ttesting loss = %.4f' % loss) print('\ttesting accuracy = %.3f' % accs['overall']) for predi in accs: if predi != 'overall': print('\t\t%s: %.3f' % (predi, accs[predi]))
def main(): args = options.parse_args() random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) gym_logger.setLevel(logging.CRITICAL) env_func = partial(get_env, args=args) env = get_env(args) reward_goal = get_goal(args) consecutive_goal_max = 10 max_iteration = args.epoch all_rewards = [] all_times = [] all_totals = [] for trial in range(args.n_trials): policy = policies.get_policy(args, env) if args.alg == 'ES': run_func = partial(envs.run_env_ES, policy=policy, env_func=env_func) alg = ESModule( policy, run_func, population_size=args.population_size, # HYPERPARAMETER sigma=args.sigma, # HYPERPARAMETER learning_rate=args.lr, # HYPERPARAMETER TODO:CHANGE threadcount=args.population_size) elif args.alg == 'PPO': run_func = partial(envs.run_env_PPO, env_func=env_func) # TODO: update alg = PPOModule( policy, run_func, n_updates=args.n_updates, # HYPERPARAMETER batch_size=args.batch_size, # HYPERPARAMETER max_steps=args.max_steps, gamma=args.gamma, clip=args.clip, ent_coeff=args.ent_coeff, learning_rate=args.lr) # TODO: CHANGE elif args.alg == 'ESPPO': run_func = partial(envs.run_env_PPO, env_func=env_func) alg = ESPPOModule( policy, run_func, population_size=args.population_size, # HYPERPARAMETER sigma=args.sigma, # HYPERPARAMETER n_updates=args.n_updates, # HYPERPARAMETER batch_size=args.batch_size, # HYPERPARAMETER max_steps=args.max_steps, gamma=args.gamma, clip=args.clip, ent_coeff=args.ent_coeff, n_seq=args.n_seq, ppo_learning_rate=args.ppo_lr, es_learning_rate=args.es_lr, threadcount=args.population_size) elif args.alg == 'MAXPPO': run_func = partial(envs.run_env_PPO, env_func=env_func) alg = MaxPPOModule( policy, run_func, population_size=args.population_size, # HYPERPARAMETER sigma=args.sigma, # HYPERPARAMETER n_updates=args.n_updates, # HYPERPARAMETER batch_size=args.batch_size, # HYPERPARAMETER max_steps=args.max_steps, gamma=args.gamma, clip=args.clip, ent_coeff=args.ent_coeff, n_seq=args.n_seq, ppo_learning_rate=args.ppo_lr, threadcount=args.population_size) elif args.alg == 'ALTPPO': run_func = partial(envs.run_env_PPO, env_func=env_func) alg = AltPPOModule( policy, run_func, population_size=args.population_size, # HYPERPARAMETER sigma=args.sigma, # HYPERPARAMETER n_updates=args.n_updates, # HYPERPARAMETER batch_size=args.batch_size, # HYPERPARAMETER max_steps=args.max_steps, gamma=args.gamma, clip=args.clip, ent_coeff=args.ent_coeff, n_alt=args.n_alt, es_learning_rate=args.es_lr, ppo_learning_rate=args.ppo_lr, threadcount=args.population_size) if args.render: with open(os.path.join(args.directory, 'weights.pkl'), 'rb') as fp: weights = pickle.load(fp) policy.load_state_dict(weights) if args.alg == 'ES': total_reward = run_func(weights, stochastic=False, render=True) else: total_reward = run_func(policy, stochastic=False, render=True, reward_only=True) print(f"Total rewards from episode: {total_rewards}") return exp_dir = os.path.join(args.directory, alg.model_name) if not os.path.exists(exp_dir): os.makedirs(exp_dir) start = time.time() consecutive_goal_count = 0 iteration = 0 rewards = [] while True: if iteration >= max_iteration: break weights = alg.step() if (iteration + 1) % 10 == 0: if args.alg == 'ES': test_reward = run_func(weights, stochastic=False, render=False) else: test_reward = run_func(policy, stochastic=False, render=False, reward_only=True) rewards.append(test_reward) print('iter %d. reward: %f' % (iteration + 1, test_reward)) if consecutive_goal_max and reward_goal: consecutive_goal_count = consecutive_goal_count + 1 if test_reward >= reward_goal else 0 if consecutive_goal_count >= consecutive_goal_max: break iteration += 1 end = time.time() - start if args.alg == 'ES': total_reward = run_func(weights, stochastic=False, render=False) else: total_reward = run_func(policy, stochastic=False, render=False, reward_only=True) all_rewards.append(rewards) all_times.append(end) all_totals.append(total_reward) print(f"Reward from final weights: {total_reward}") print(f"Time to completion: {end}") max_len = 0 for rewards in all_rewards: if len(rewards) > max_len: max_len = len(rewards) for rewards in all_rewards: while len(rewards) < max_len: rewards.append(reward_goal) rewards = np.array(rewards) all_rewards = np.array(all_rewards) rewards_mean = np.mean(all_rewards, axis=0) rewards_std = np.std(all_rewards, axis=0) total_mean = np.mean(all_totals) time_mean = np.mean(all_times) plt.errorbar(np.arange(max_len), rewards_mean, yerr=rewards_std, label='rewards') plt.legend(loc=4) plt.grid(True) plt.tight_layout() path = os.path.join(exp_dir, "rewards_plot.png") plt.savefig(path) plt.close() np.savetxt(os.path.join(exp_dir, 'rewards.txt'), rewards_mean) pickle.dump(weights, open(os.path.join(exp_dir, 'weights.pkl'), 'wb')) out_file = open(os.path.join(exp_dir, "results.txt"), 'w') print(f"Average rewards from final weights: {total_mean}") msg = f"Average rewards from final weights: {total_mean}" msg += "\n" print(f"Average time to completion: {time_mean}") msg += f"Average time to completion: {time_mean}" msg += "\n" print(f"Results saved at: {exp_dir}") out_file.write(msg) out_file.flush()
if vocab_subset is not None: # filter log_probs filter_logprob_indices, index_list = model.init_indices_for_filter_logprobs( vocab_subset) filtered_log_probs_list = model.filter_logprobs( original_log_probs_list, filter_logprob_indices) print(filtered_log_probs_list) else: filtered_log_probs_list = original_log_probs_list ret = {} # rank over the subset of the vocab (if defined) for the SINGLE masked tokens if masked_indices and len(masked_indices) > 0: ret = evaluation_metrics.get_ranking( filtered_log_probs_list[0], masked_indices, model.vocab, index_list=index_list) # prediction and perplexity for the whole softmax # print_sentence_predictions(original_log_probs_list[0], token_ids, model.vocab, masked_indices=masked_indices for r in ret: print("%s %s" % (r, ret[r])) if __name__ == '__main__': parser = options.get_eval_generation_parser() args = options.parse_args(parser) main(args)
def main(): args = parse_args() dataloader_train = create_dataloader(args.train_split, False, args) dataloader_valid = create_dataloader('valid', False, args) dataloader_test = create_dataloader('test', False, args) print('%d batches of training examples' % len(dataloader_train)) print('%d batches of validation examples' % len(dataloader_valid)) print('%d batches of testing examples' % len(dataloader_test)) phrase_encoder = RecurrentPhraseEncoder(300, 300) model = SimpleLanguageOnlyModel(phrase_encoder, args.feature_dim, 9) criterion = nn.BCEWithLogitsLoss() if torch.cuda.is_available(): model.cuda() criterion.cuda() optimizer = torch.optim.RMSprop(model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.l2) if args.train_split == 'train_valid': scheduler = StepLR(optimizer, step_size=8, gamma=0.1) else: scheduler = ReduceLROnPlateau(optimizer, patience=5, verbose=True) best_acc = -1. for epoch in range(args.n_epochs): print('epoch #%d' % epoch) print('training..') loss, acc = train(model, criterion, optimizer, dataloader_train, epoch, args) print('\n\ttraining loss = %.4f' % loss) print('\ttraining accuracy = %.3f' % acc) print('validating..') loss, accs = test('valid', model, criterion, dataloader_valid, epoch, args) print('\n\tvalidation loss = %.4f' % loss) print('\tvalidation accuracy = %.3f' % accs['overall']) for predi in accs: if predi != 'overall': print('\t\t%s: %.3f' % (predi, accs[predi])) checkpoint_filename = os.path.join( args.log_dir, 'checkpoints/model_%02d.pth' % epoch) model.cpu() torch.save( { 'epoch': epoch + 1, 'args': args, 'state_dict': model.state_dict(), 'accuracy': acc, 'optimizer': optimizer.state_dict(), }, checkpoint_filename) if torch.cuda.is_available(): model.cuda() if best_acc < acc: best_acc = acc shutil.copyfile( checkpoint_filename, os.path.join(args.log_dir, 'checkpoints/model_best.pth')) shutil.copyfile( os.path.join(args.log_dir, 'predictions/pred_%02d.pickle' % epoch), os.path.join(args.log_dir, 'predictions/pred_best.pickle')) if args.train_split == 'train_valid': scheduler.step() else: scheduler.step(loss) print('testing..') loss, accs = test('test', model, criterion, dataloader_test, epoch, args) print('\n\ttesting loss = %.4f' % loss) print('\ttesting accuracy = %.3f' % accs['overall']) for predi in accs: if predi != 'overall': print('\t\t%s: %.3f' % (predi, accs[predi]))
print("GG! Best accuracy {:f}".format(max_acc)) if ((epoch + 1) % params.save_freq == 0) or (epoch == stop_epoch - 1): outfile = os.path.join(params.checkpoint_dir, '{:d}.tar'.format(epoch)) torch.save({'epoch': epoch, 'state': model.state_dict()}, outfile) return model # --- main function --- if __name__ == '__main__': # set numpy random seed np.random.seed(10) # parser argument params = parse_args() print('--- Training ---\n') print(params) # output and tensorboard dir params.checkpoint_dir = '%s/checkpoints/%s' % (params.save_dir, params.name) if not os.path.isdir(params.checkpoint_dir): os.makedirs(params.checkpoint_dir) # dataloader print('\n--- Prepare dataloader ---') print('\ttrain with seen domain {}'.format(params.dataset)) print('\tval with seen domain {}'.format(params.testset)) base_file = os.path.join(params.data_dir, params.dataset, 'base.json') val_file = os.path.join(params.data_dir, params.testset, 'val.json')
import os import logging import numpy as np import random import pickle import torch # Env from data_loaders import * from options import parse_args from train_test import train, test ### 1. Initializes parser and device opt = parse_args() device = torch.device('cuda:{}'.format(opt.gpu_ids[0])) if opt.gpu_ids else torch.device('cpu') print("Using device:", device) if not os.path.exists(opt.checkpoints_dir): os.makedirs(opt.checkpoints_dir) if not os.path.exists(os.path.join(opt.checkpoints_dir, opt.exp_name)): os.makedirs(os.path.join(opt.checkpoints_dir, opt.exp_name)) if not os.path.exists(os.path.join(opt.checkpoints_dir, opt.exp_name, opt.model_name)): os.makedirs(os.path.join(opt.checkpoints_dir, opt.exp_name, opt.model_name)) ### 2. Initializes Data ignore_missing_histype = 1 if 'grad' in opt.task else 0 ignore_missing_moltype = 1 if 'omic' in opt.mode else 0 use_patch, roi_dir = ('_patch_', 'all_st_patches_512') if opt.use_vgg_features else ('_', 'all_st') use_rnaseq = '_rnaseq' if opt.use_rnaseq else '' data_cv_path = '%s/splits/gbmlgg15cv_%s_%d_%d_%d%s.pkl' % (opt.dataroot, roi_dir, ignore_missing_moltype, ignore_missing_histype, opt.use_vgg_features, use_rnaseq) print("Loading %s" % data_cv_path) data_cv = pickle.load(open(data_cv_path, 'rb'))
def main(args): """ main function""" sys.excepthook = excepthook random_init() qname, qtype, qclass, csv = parse_args(args[1:]) try: qtype_val = qt.get_val(qtype) except KeyError: raise UsageError("ERROR: invalid query type: {}\n".format(qtype)) try: qclass_val = qc.get_val(qclass) except KeyError: raise UsageError("ERROR: invalid query class: {}\n".format(qclass)) if csv==0: query = DNSquery(qname, qtype_val, qclass_val) try: server_addr, port, family, _ = \ get_socketparams(options["server"], options["port"], options["af"], socket.SOCK_DGRAM) except socket.gaierror as e: raise ErrorMessage("bad server: %s (%s)" % (options["server"], e)) request = query.get_message() else: doc = pd.read_csv(qname) X = doc.iloc[:,0].values.astype(str) print(len(X)) for i in X: print(i) i += "." query = DNSquery(i, qtype_val, qclass_val) try: server_addr, port, family, _ = \ get_socketparams(options["server"], options["port"], options["af"], socket.SOCK_DGRAM) except socket.gaierror as e: raise ErrorMessage("bad server: %s (%s)" % (options["server"], e)) request = query.get_message() (responsepkt, responder_addr) = \ send_request_udp(request, server_addr, port, family, ITIMEOUT, RETRIES) response = DNSresponse(family, query, responsepkt) doc["get"] = str(response.decode_sections()) doc.to_csv(qname,index=False) response = None if not options["use_tcp"]: t1 = time.time() (responsepkt, responder_addr) = \ send_request_udp(request, server_addr, port, family, ITIMEOUT, RETRIES) t2 = time.time() if not responsepkt: raise ErrorMessage("No response from server") response = DNSresponse(family, query, responsepkt) if not response.tc: print(";; UDP response from %s, %d bytes, in %.3f sec" % (responder_addr, response.msglen, (t2-t1))) if not is_multicast(server_addr) and \ server_addr != "0.0.0.0" and responder_addr[0] != server_addr: print("WARNING: Response from unexpected address %s" % responder_addr[0]) if options["use_tcp"] or (response and response.tc) \ or (options["tls"] and options["tls_fallback"] and not response): if response and response.tc: if options["ignore"]: print(";; UDP Response was truncated.") else: print(";; UDP Response was truncated. Retrying using TCP ...") if options["tls"] and options["tls_fallback"] and not response: print(";; TLS fallback to TCP ...") if not options["ignore"]: t1 = time.time() responsepkt = send_request_tcp(request, server_addr, port, family) t2 = time.time() response = DNSresponse(family, query, responsepkt) print(";; TCP response from %s, %d bytes, in %.3f sec" % ((server_addr, port), response.msglen, (t2-t1))) response.print_all() dprint("Compression pointer dereferences=%d" % Stats.compression_cnt) return response.rcode
def main(): args = parse_args() dataloader_train = create_dataloader(args.train_split, True, args) dataloader_valid = create_dataloader("valid", True, args) dataloader_test = create_dataloader("test", True, args) print("%d batches of training examples" % len(dataloader_train)) print("%d batches of validation examples" % len(dataloader_valid)) print("%d batches of testing examples" % len(dataloader_test)) phrase_encoder = RecurrentPhraseEncoder(300, 300) if args.model == "drnet": model = DRNet(phrase_encoder, args.feature_dim) elif args.model == "vtranse": model = VtransE(phrase_encoder, args.visual_feature_size, args.predicate_embedding_dim) elif args.model == "vipcnn": model = VipCNN(roi_size=args.roi_size, backbone=args.backbone) else: model = PPRFCN(backbone=args.backbone) model.cuda() print(model) criterion = nn.BCEWithLogitsLoss() criterion.cuda() optimizer = torch.optim.RMSprop( [p for p in model.parameters() if p.requires_grad], lr=args.learning_rate, momentum=args.momentum, weight_decay=args.l2, ) if args.train_split == "train": scheduler = ReduceLROnPlateau(optimizer, patience=4, verbose=True) else: scheduler = StepLR(optimizer, step_size=args.patience, gamma=0.1) start_epoch = 0 if args.resume != None: print(" => loading model checkpoint from %s.." % args.resume) checkpoint = torch.load(args.resume) model.load_state_dict(checkpoint["state_dict"]) model.cuda() optimizer.load_state_dict(checkpoint["optimizer"]) start_epoch = checkpoint["epoch"] best_acc = -1.0 for epoch in range(start_epoch, start_epoch + args.n_epochs): print("epoch #%d" % epoch) print("training..") loss, acc = train(model, criterion, optimizer, dataloader_train, epoch, args) print("\n\ttraining loss = %.4f" % loss) print("\ttraining accuracy = %.3f" % acc) if args.train_split != "train_valid": print("validating..") loss, accs = test("valid", model, criterion, dataloader_valid, epoch, args) print("\n\tvalidation loss = %.4f" % loss) print("\tvalidation accuracy = %.3f" % accs["overall"]) for predi in accs: if predi != "overall": print("\t\t%s: %.3f" % (predi, accs[predi])) checkpoint_filename = os.path.join( args.log_dir, "checkpoints/model_%02d.pth" % epoch) model.cpu() torch.save( { "epoch": epoch + 1, "args": args, "state_dict": model.state_dict(), "accuracy": acc, "optimizer": optimizer.state_dict(), }, checkpoint_filename, ) model.cuda() if args.train_split != "train_valid" and best_acc < acc: best_acc = acc shutil.copyfile( checkpoint_filename, os.path.join(args.log_dir, "checkpoints/model_best.pth"), ) shutil.copyfile( os.path.join(args.log_dir, "predictions/pred_%02d.pickle" % epoch), os.path.join(args.log_dir, "predictions/pred_best.pickle"), ) if args.train_split == "train": scheduler.step(loss) else: scheduler.step() print("testing..") loss, accs = test("test", model, criterion, dataloader_test, None, args) print("\n\ttesting loss = %.4f" % loss) print("\ttesting accuracy = %.3f" % accs["overall"]) for predi in accs: if predi != "overall": print("\t\t%s: %.3f" % (predi, accs[predi]))
if ((epoch + 1) % params.save_freq == 0) or (epoch == stop_epoch - 1): outfile = os.path.join(params.checkpoint_dir, '{:d}.tar'.format(epoch + 1)) model.save(outfile, epoch) outfile = os.path.join(params.checkpoint_dir, name + '_trlog') torch.save(trlog, outfile) return # --- main function --- if __name__ == '__main__': # set numpy random seed np.random.seed(10) # parse argument params = parse_args('train') if params.mode in ['onlytrain', 'train_and_test']: if params.train_aug == 'True': name = 'original_shot_' + str(params.n_shot) + '_query_' + str( params.n_query ) + '_' + params.method + '_' + params.testset + '_aug' elif params.train_aug == 'False': name = 'original_shot_' + str(params.n_shot) + '_query_' + str( params.n_query) + '_' + params.method + '_' + params.testset print('--- LFTNet training: {} ---\n'.format(name)) print(params) # output and tensorboard dir params.tf_dir = '%s/log/%s' % (params.save_dir, name) params.checkpoint_dir = '%s/checkmodels/%s' % (params.save_dir, name)
def explain_relationnet(): # print(sys.path) params = options.parse_args('test') feature_model = backbone.model_dict['ResNet10'] params.method = 'relationnet' params.dataset = 'miniImagenet' # name relationnet --testset miniImagenet params.name = 'relationnet' params.testset = 'miniImagenet' params.data_dir = '/home/sunjiamei/work/fewshotlearning/dataset/' params.save_dir = '/home/sunjiamei/work/fewshotlearning/CrossDomainFewShot-master/output' if 'Conv' in params.model: image_size = 84 else: image_size = 224 split = params.split n_query = 1 loadfile = os.path.join(params.data_dir, params.testset, split + '.json') few_shot_params = dict(n_way=params.test_n_way, n_support=params.n_shot) data_datamgr = SetDataManager(image_size, n_query=n_query, **few_shot_params) data_loader = data_datamgr.get_data_loader(loadfile, aug=False) acc_all = [] iter_num = 1000 # model print(' build metric-based model') if params.method == 'protonet': model = ProtoNet(backbone.model_dict[params.model], **few_shot_params) elif params.method == 'matchingnet': model = MatchingNet(backbone.model_dict[params.model], **few_shot_params) elif params.method == 'gnnnet': model = GnnNet(backbone.model_dict[params.model], **few_shot_params) elif params.method in ['relationnet', 'relationnet_softmax']: if params.model == 'Conv4': feature_model = backbone.Conv4NP elif params.model == 'Conv6': feature_model = backbone.Conv6NP else: feature_model = backbone.model_dict[params.model] loss_type = 'LRPmse' model = RelationNet(feature_model, loss_type=loss_type, **few_shot_params) else: raise ValueError('Unknown method') checkpoint_dir = '%s/checkpoints/%s' % (params.save_dir, params.name) # print(checkpoint_dir) if params.save_epoch != -1: modelfile = get_assigned_file(checkpoint_dir, params.save_epoch) else: modelfile = get_best_file(checkpoint_dir) # print(modelfile) if modelfile is not None: tmp = torch.load(modelfile) try: model.load_state_dict(tmp['state']) except RuntimeError: print('warning! RuntimeError when load_state_dict()!') model.load_state_dict(tmp['state'], strict=False) except KeyError: for k in tmp['model_state']: ##### revise latter if 'running' in k: tmp['model_state'][k] = tmp['model_state'][k].squeeze() model.load_state_dict(tmp['model_state'], strict=False) except: raise model = model.cuda() model.eval() model.n_query = n_query # ---test the accuracy on the test set to verify the model is loaded---- acc = 0 count = 0 # for i, (x, y) in enumerate(data_loader): # scores = model.set_forward(x) # pred = scores.data.cpu().numpy().argmax(axis=1) # y = np.repeat(range(model.n_way), n_query) # acc += np.sum(pred == y) # count += len(y) # # print(1.0*acc/count) # print(1.0*acc/count) preset = lrp_presets.SequentialPresetA() feature_model = copy.deepcopy(model.feature) lrp_wrapper.add_lrp(feature_model, preset=preset) relation_model = copy.deepcopy(model.relation_module) # print(relation_model) lrp_wrapper.add_lrp(relation_model, preset=preset) with open( '/home/sunjiamei/work/fewshotlearning/dataset/miniImagenet/class_to_readablelabel.json', 'r') as f: class_to_readable = json.load(f) explanation_save_dir = os.path.join(params.save_dir, 'explanations', params.name) if not os.path.isdir(explanation_save_dir): os.makedirs(explanation_save_dir) for i, (x, y, p) in enumerate(data_loader): '''x is the images with shape as n_way, n_support + n_querry, 3, img_size, img_size y is the global labels of the images with shape as (n_way, n_support + n_query) p is the image path as a list of tuples, length is n_query+n_support, each tuple element is with length n_way''' if i >= 3: break label_to_readableclass, query_img_path, query_gt_class = LRPutil.get_class_label( p, class_to_readable, model.n_query) z_support, z_query = model.parse_feature(x, is_feature=False) z_support = z_support.contiguous() z_proto = z_support.view(model.n_way, model.n_support, *model.feat_dim).mean(1) # print(z_proto.shape) z_query = z_query.contiguous().view(model.n_way * model.n_query, *model.feat_dim) # print(z_query.shape) # get relations with metric function z_proto_ext = z_proto.unsqueeze(0).repeat(model.n_query * model.n_way, 1, 1, 1, 1) # print(z_proto_ext.shape) z_query_ext = z_query.unsqueeze(0).repeat(model.n_way, 1, 1, 1, 1) z_query_ext = torch.transpose(z_query_ext, 0, 1) # print(z_query_ext.shape) extend_final_feat_dim = model.feat_dim.copy() extend_final_feat_dim[0] *= 2 relation_pairs = torch.cat((z_proto_ext, z_query_ext), 2).view(-1, *extend_final_feat_dim) # print(relation_pairs.shape) relations = relation_model(relation_pairs) # print(relations) scores = relations.view(-1, model.n_way) preds = scores.data.cpu().numpy().argmax(axis=1) # print(preds.shape) relations = relations.view(-1, model.n_way) # print(relations) relations_sf = torch.softmax(relations, dim=-1) # print(relations_sf) relations_logits = torch.log(LRPutil.LOGIT_BETA * relations_sf / (1 - relations_sf)) # print(relations_logits) # print(preds) relations_logits = relations_logits.view(-1, 1) relevance_relations = relation_model.compute_lrp( relation_pairs, target=relations_logits) # print(relevance_relations.shape) # print(model.feat_dim) relevance_z_query = torch.narrow(relevance_relations, 1, model.feat_dim[0], model.feat_dim[0]) # print(relevance_z_query.shape) relevance_z_query = relevance_z_query.view( model.n_query * model.n_way, model.n_way, *relevance_z_query.size()[1:]) # print(relevance_z_query.shape) query_img = x.narrow(1, model.n_support, model.n_query).view(model.n_way * model.n_query, *x.size()[2:]) # query_img_copy = query_img.view(model.n_way, model.n_query, *x.size()[2:]) # print(query_img.shape) for k in range(model.n_way): relevance_querry_cls = torch.narrow(relevance_z_query, 1, k, 1).squeeze(1) # print(relevance_querry_cls.shape) relevance_querry_img = feature_model.compute_lrp( query_img.cuda(), target=relevance_querry_cls) # print(relevance_querry_img.max(), relevance_querry_img.min()) # print(relevance_querry_img.shape) for j in range(model.n_query * model.n_way): predict_class = label_to_readableclass[preds[j]] true_class = query_gt_class[int(j % model.n_way)][int( j // model.n_way)] explain_class = label_to_readableclass[k] img_name = query_img_path[int(j % model.n_way)][int( j // model.n_way)].split('/')[-1] if not os.path.isdir( os.path.join(explanation_save_dir, 'episode' + str(i), img_name.strip('.jpg'))): os.makedirs( os.path.join(explanation_save_dir, 'episode' + str(i), img_name.strip('.jpg'))) save_path = os.path.join(explanation_save_dir, 'episode' + str(i), img_name.strip('.jpg')) if not os.path.exists( os.path.join( save_path, true_class + '_' + predict_class + img_name)): original_img = Image.fromarray( np.uint8( project(query_img[j].permute(1, 2, 0).cpu().numpy()))) original_img.save( os.path.join( save_path, true_class + '_' + predict_class + img_name)) img_relevance = relevance_querry_img.narrow(0, j, 1) print(predict_class, true_class, explain_class) # assert relevance_querry_cls[j].sum() != 0 # assert img_relevance.sum()!=0 hm = img_relevance.permute(0, 2, 3, 1).cpu().detach().numpy() hm = LRPutil.gamma(hm) hm = LRPutil.heatmap(hm)[0] hm = project(hm) hp_img = Image.fromarray(np.uint8(hm)) hp_img.save( os.path.join( save_path, true_class + '_' + explain_class + '_lrp_hm.jpg'))
if ((epoch + 1) % params.save_freq == 0) or (epoch == stop_epoch - 1): outfile = os.path.join(params.checkpoint_dir, '{:d}.tar'.format(epoch)) torch.save({'epoch': epoch, 'state': model.state_dict()}, outfile) return model # --- main function --- if __name__ == '__main__': # set numpy random seed np.random.seed(10) # parser argument params = parse_args( 'train') #model_dict=conv4, conv6, resnet10, resnet18,resnet34 print('--- baseline training: {} ---\n'.format(params.name)) print(params) # output and tensorboard dir params.tf_dir = '%s/log/%s' % (params.save_dir, params.name) params.checkpoint_dir = '%s/checkpoints/%s' % (params.save_dir, params.name) if not os.path.isdir(params.checkpoint_dir): os.makedirs(params.checkpoint_dir) # dataloader print('\n--- prepare dataloader ---') if params.dataset == 'multi': print(' train with multiple seen domains (unseen domain: {})'.format( params.testset))
from torch.utils.data import DataLoader import models from options import parse_args from utils import Logger, AverageMeter, ClassErrorMeter from datasets import get_dataset from utils.measure_v2 import measure torch.backends.cudnn.benchmark = True ########################### # DEFINE GLOBAL VARIABLES # ########################### # parse arguments args, model_args = parse_args() # define logger logdir = args.logdir logger = Logger(logdir, read_only=args.test_only) logger.log('args: %s'%str(args)) logger.log('model args: %s'%str(model_args)) # define model model = models.__dict__[args.model](**vars(model_args)).cuda() # logger.log('full-model FLOPs: %d' % measure(model, torch.zeros(1, 3, 32, 32).cuda())[0]) # define datasets - 0: train, 1: val, 2: test datasets = get_dataset(args.dataset, val_size=args.valsize) dataloaders = [] for d in datasets:
def main(): args = parse_args() dataloader_train = create_dataloader(args.train_split, False, args) dataloader_valid = create_dataloader("valid", False, args) dataloader_test = create_dataloader("test", False, args) print("%d batches of training examples" % len(dataloader_train)) print("%d batches of validation examples" % len(dataloader_valid)) print("%d batches of testing examples" % len(dataloader_test)) model = SimpleSpatialModel(4, args.feature_dim, 9) print(model) criterion = nn.BCEWithLogitsLoss() if torch.cuda.is_available(): model.cuda() criterion.cuda() optimizer = torch.optim.RMSprop( model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.l2, ) if args.train_split == "train_valid": scheduler = StepLR(optimizer, step_size=21, gamma=0.1) else: scheduler = ReduceLROnPlateau(optimizer, patience=5, verbose=True) best_acc = -1.0 for epoch in range(args.n_epochs): print("epoch #%d" % epoch) print("training..") loss, acc = train(model, criterion, optimizer, dataloader_train, epoch, args) print("\n\ttraining loss = %.4f" % loss) print("\ttraining accuracy = %.3f" % acc) print("validating..") loss, accs = test("valid", model, criterion, dataloader_valid, epoch, args) print("\n\tvalidation loss = %.4f" % loss) print("\tvalidation accuracy = %.3f" % accs["overall"]) for predi in accs: if predi != "overall": print("\t\t%s: %.3f" % (predi, accs[predi])) checkpoint_filename = os.path.join( args.log_dir, "checkpoints/model_%02d.pth" % epoch ) model.cpu() torch.save( { "epoch": epoch + 1, "args": args, "state_dict": model.state_dict(), "accuracy": acc, "optimizer": optimizer.state_dict(), }, checkpoint_filename, ) if torch.cuda.is_available(): model.cuda() if best_acc < acc: best_acc = acc shutil.copyfile( checkpoint_filename, os.path.join(args.log_dir, "checkpoints/model_best.pth"), ) shutil.copyfile( os.path.join(args.log_dir, "predictions/pred_%02d.pickle" % epoch), os.path.join(args.log_dir, "predictions/pred_best.pickle"), ) if args.train_split == "train_valid": scheduler.step() else: scheduler.step(loss) print("testing..") _, accs = test("test", model, criterion, dataloader_test, epoch, args) print("\ttesting accuracies = %.3f" % accs["overall"]) for predi in accs: if predi != "overall": print("\t\t%s: %.3f" % (predi, accs[predi]))
]) z_all = torch.from_numpy(np.array(z_all)) model.n_query = n_query scores = model.set_forward(z_all, is_feature=True) pred = scores.data.cpu().numpy().argmax(axis=1) y = np.repeat(range(n_way), n_query) acc = np.mean(pred == y) * 100 return acc # --- main --- if __name__ == '__main__': # parse argument params = parse_args('test') print('Testing! {} shots on {} dataset with {} epochs of {}({})'.format( params.n_shot, params.dataset, params.save_epoch, params.name, params.method)) remove_featurefile = True print('\nStage 1: saving features') # dataset print(' build dataset') if 'Conv' in params.model: image_size = 84 else: image_size = 224 split = params.split loadfile = os.path.join(params.data_dir, params.dataset, split + '.json') datamgr = SimpleDataManager(image_size, batch_size=64)
if ((epoch + 1) % params.save_freq == 0) or (epoch == stop_epoch - 1): outfile = os.path.join(params.checkpoint_dir, '{:d}.tar'.format(epoch + 1)) model.save(outfile, epoch) return # --- main function --- if __name__ == '__main__': # set numpy random seed np.random.seed(10) # parse argument params = parse_args('train') print('--- LFTNet training: {} ---\n'.format(params.name)) print(params) # output and tensorboard dir params.tf_dir = '%s/log/%s' % (params.save_dir, params.name) params.checkpoint_dir = '%s/checkpoints/%s' % (params.save_dir, params.name) if not os.path.isdir(params.checkpoint_dir): os.makedirs(params.checkpoint_dir) # dataloader print('\n--- prepare dataloader ---') print(' train with multiple seen domains (unseen domain: {})'.format( params.testset)) datasets = ['miniImagenet', 'cars', 'places', 'cub', 'plantae']
def main(): time1 = datetime.strftime(datetime.now(), '%Y%m%d%H%M%S') fh = open('/home/lx/DRNet/experiment/spatialrel/rel' + time1 + '.txt', 'w', encoding='utf-8') args = parse_args() if args.custom_on == 'on': dataloader_train = create_dataloader_depth(args.train_split, True, args) dataloader_valid = create_dataloader_depth('valid', True, args) dataloader_test = create_dataloader_depth('test', True, args) else: dataloader_train = create_dataloader(args.train_split, True, args) dataloader_valid = create_dataloader('valid', True, args) dataloader_test = create_dataloader('test', True, args) print('%d batches of training examples' % len(dataloader_train)) print('%d batches of validation examples' % len(dataloader_valid)) print('%d batches of testing examples' % len(dataloader_test)) phrase_encoder = RecurrentPhraseEncoder(300, 300) if args.depth_on == 'on': model = DRNet_depth(phrase_encoder, args.feature_dim, args.num_layers, args) else: model = DRNet(phrase_encoder, args.feature_dim, args.num_layers, args) model.cuda() # criterion = nn.BCEWithLogitsLoss() criterion = nn.CrossEntropyLoss() criterion.cuda() optimizer = torch.optim.RMSprop( [p for p in model.parameters() if p.requires_grad], lr=args.learning_rate, momentum=args.momentum, weight_decay=args.l2) if args.train_split == 'train': scheduler = ReduceLROnPlateau(optimizer, patience=4, verbose=True) else: scheduler = StepLR(optimizer, step_size=args.patience, gamma=0.1) start_epoch = 0 if args.resume != None: print(' => loading model checkpoint from %s..' % args.resume) checkpoint = torch.load(args.resume) model.load_state_dict(checkpoint['state_dict']) model.cuda() optimizer.load_state_dict(checkpoint['optimizer']) start_epoch = checkpoint['epoch'] best_acc = -1. for epoch in range(start_epoch, start_epoch + args.n_epochs): print('epoch #%d' % epoch) print('training..') loss, acc = train(model, criterion, optimizer, dataloader_train, epoch, args) print('\n\ttraining loss = %.4f' % loss) print('\ttraining accuracy = %.3f' % acc) checkpoint_filename = os.path.join( args.log_dir, 'checkpoints/model_%.3f_%02d.pth' % (acc, epoch)) if epoch % 5 == 0: print('validating..') torch.cuda.synchronize() start = time.time() loss, acc = test('valid', model, criterion, dataloader_valid, epoch, args) torch.cuda.synchronize() end = time.time() dtime = ((end - start) / len(dataloader_valid) / args.batchsize) print('\n\tvalidation loss = %.4f' % loss) print('\tvalidation accuracy = %.3f' % acc) print('\tvalidation time per input = %.3f' % dtime) model.cpu() torch.save( { 'epoch': epoch + 1, 'args': args, 'state_dict': model.state_dict(), 'accuracy': acc, 'optimizer': optimizer.state_dict(), }, checkpoint_filename) model.cuda() if args.train_split != 'train_valid' and best_acc < acc: best_acc = acc shutil.copyfile( checkpoint_filename, os.path.join(args.log_dir, 'checkpoints/model_best.pth')) shutil.copyfile( os.path.join(args.log_dir, 'predictions/pred_%02d.pickle' % epoch), os.path.join(args.log_dir, 'predictions/pred_best.pickle')) if args.train_split == 'train': scheduler.step(loss) else: scheduler.step() print('testing..') loss, acc = test('test', model, criterion, dataloader_test, None, args) print('\n\ttesting loss = %.4f' % loss) print('\ttesting accuracy = %.3f' % acc) fh.close()
def answer(topic=None): """ Main rendering function, it processes incoming weather queries. Depending on user agent it returns output in HTML or ANSI format. Incoming data: request.args request.headers request.remote_addr request.referrer request.query_string """ user_agent = request.headers.get('User-Agent', '').lower() html_needed = _is_html_needed(user_agent) options = parse_args(request.args) if topic in ['apple-touch-icon-precomposed.png', 'apple-touch-icon.png', 'apple-touch-icon-120x120-precomposed.png'] \ or (topic is not None and any(topic.endswith('/'+x) for x in ['favicon.ico'])): return '' request_id = request.cookies.get('id') if topic is not None and topic.lstrip('/') == ':last': if request_id: topic = last_query(request_id) else: return "ERROR: you have to set id for your requests to use /:last\n" else: if request_id: save_query(request_id, topic) if request.method == 'POST': process_post_request(request, html_needed) if html_needed: return redirect("/") return "OK\n" if 'topic' in request.args: return redirect("/%s" % request.args.get('topic')) if topic is None: topic = ":firstpage" if topic.startswith(':shell-x/'): return _proxy() #return requests.get('http://127.0.0.1:3000'+topic[8:]).text lang = get_answer_language(request) if lang: options['lang'] = lang ip_address = get_request_ip(request) if '+' in topic: not_allowed = LIMITS.check_ip(ip_address) if not_allowed: return "429 %s\n" % not_allowed, 429 html_is_needed = _is_html_needed( user_agent) and not is_result_a_script(topic) if html_is_needed: output_format = 'html' else: output_format = 'ansi' result, found = cheat_wrapper(topic, request_options=options, output_format=output_format) if 'Please come back in several hours' in result and html_is_needed: malformed_response = open( os.path.join(CONFIG["path.internal.malformed"])).read() return malformed_response log_query(ip_address, found, topic, user_agent) if html_is_needed: return result return Response(result, mimetype='text/plain')
def explain_gnnnet(): params = options.parse_args('test') feature_model = backbone.model_dict['ResNet10'] params.method = 'gnnnet' params.dataset = 'miniImagenet' # name relationnet --testset miniImagenet params.name = 'gnn' params.testset = 'miniImagenet' params.data_dir = '/home/sunjiamei/work/fewshotlearning/dataset/' params.save_dir = '/home/sunjiamei/work/fewshotlearning/CrossDomainFewShot-master/output' if 'Conv' in params.model: image_size = 84 else: image_size = 224 split = params.split n_query = 1 loadfile = os.path.join(params.data_dir, params.testset, split + '.json') few_shot_params = dict(n_way=params.test_n_way, n_support=params.n_shot) data_datamgr = SetDataManager(image_size, n_query=n_query, **few_shot_params) data_loader = data_datamgr.get_data_loader(loadfile, aug=False) # model print(' build metric-based model') if params.method == 'protonet': model = ProtoNet(backbone.model_dict[params.model], **few_shot_params) elif params.method == 'matchingnet': model = MatchingNet(backbone.model_dict[params.model], **few_shot_params) elif params.method == 'gnnnet': model = GnnNet(backbone.model_dict[params.model], **few_shot_params) elif params.method in ['relationnet', 'relationnet_softmax']: if params.model == 'Conv4': feature_model = backbone.Conv4NP elif params.model == 'Conv6': feature_model = backbone.Conv6NP else: feature_model = backbone.model_dict[params.model] loss_type = 'LRP' model = RelationNet(feature_model, loss_type=loss_type, **few_shot_params) else: raise ValueError('Unknown method') checkpoint_dir = '%s/checkpoints/%s' % (params.save_dir, params.name) # print(checkpoint_dir) if params.save_epoch != -1: modelfile = get_assigned_file(checkpoint_dir, params.save_epoch) else: modelfile = get_best_file(checkpoint_dir) # print(modelfile) if modelfile is not None: tmp = torch.load(modelfile) try: model.load_state_dict(tmp['state']) print('loaded pretrained model') except RuntimeError: print('warning! RuntimeError when load_state_dict()!') model.load_state_dict(tmp['state'], strict=False) except KeyError: for k in tmp['model_state']: ##### revise latter if 'running' in k: tmp['model_state'][k] = tmp['model_state'][k].squeeze() model.load_state_dict(tmp['model_state'], strict=False) except: raise model = model.cuda() model.eval() model.n_query = n_query # for module in model.modules(): # print(type(module)) lrp_preset = lrp_presets.SequentialPresetA() feature_model = model.feature fc_encoder = model.fc gnn_net = model.gnn lrp_wrapper.add_lrp(fc_encoder, lrp_preset) # lrp_wrapper.add_lrp(feature_model, lrp_preset) # lrp_wrapper.add_lrp(fc_encoder,lrp_preset) # lrp_wrapper.add_lrp(feature_model, lrp_preset) # acc = 0 # count = 0 # tested the forward pass is correct by observing the accuracy # for i, (x, _, _) in enumerate(data_loader): # x = x.cuda() # support_label = torch.from_numpy(np.repeat(range(model.n_way), model.n_support)).unsqueeze(1) # support_label = torch.zeros(model.n_way*model.n_support, model.n_way).scatter(1, support_label, 1).view(model.n_way, model.n_support, model.n_way) # support_label = torch.cat([support_label, torch.zeros(model.n_way, 1, model.n_way)], dim=1) # support_label = support_label.view(1, -1, model.n_way) # support_label = support_label.cuda() # x = x.view(-1, *x.size()[2:]) # # x_feature = feature_model(x) # x_fc_encoded = fc_encoder(x_feature) # z = x_fc_encoded.view(model.n_way, -1, x_fc_encoded.size(1)) # gnn_feature = [ # torch.cat([z[:, :model.n_support], z[:, model.n_support + i:model.n_support + i + 1]], dim=1).view(1, -1, z.size(2)) # for i in range(model.n_query)] # gnn_nodes = torch.cat([torch.cat([z, support_label], dim=2) for z in gnn_feature], dim=0) # scores = gnn_net(gnn_nodes) # scores = scores.view(model.n_query, model.n_way, model.n_support + 1, model.n_way)[:, :, -1].permute(1, 0, # 2).contiguous().view( # -1, model.n_way) # pred = scores.data.cpu().numpy().argmax(axis=1) # y = np.repeat(range(model.n_way), n_query) # acc += np.sum(pred == y) # count += len(y) # # print(1.0*acc/count) # print(1.0*acc/count) with open( '/home/sunjiamei/work/fewshotlearning/dataset/miniImagenet/class_to_readablelabel.json', 'r') as f: class_to_readable = json.load(f) explanation_save_dir = os.path.join(params.save_dir, 'explanations', params.name) if not os.path.isdir(explanation_save_dir): os.makedirs(explanation_save_dir) for batch_idx, (x, y, p) in enumerate(data_loader): print(p) label_to_readableclass, query_img_path, query_gt_class = LRPutil.get_class_label( p, class_to_readable, model.n_query) x = x.cuda() support_label = torch.from_numpy( np.repeat(range(model.n_way), model.n_support)).unsqueeze(1) #torch.Size([25, 1]) support_label = torch.zeros(model.n_way * model.n_support, model.n_way).scatter(1, support_label, 1).view( model.n_way, model.n_support, model.n_way) support_label = torch.cat( [support_label, torch.zeros(model.n_way, 1, model.n_way)], dim=1) support_label = support_label.view(1, -1, model.n_way) support_label = support_label.cuda() #torch.Size([1, 30, 5]) x = x.contiguous() x = x.view(-1, *x.size()[2:]) #torch.Size([30, 3, 224, 224]) x_feature = feature_model(x) #torch.Size([30, 512]) x_fc_encoded = fc_encoder(x_feature) #torch.Size([30, 128]) z = x_fc_encoded.view(model.n_way, -1, x_fc_encoded.size(1)) # (5,6,128) gnn_feature = [ torch.cat([ z[:, :model.n_support], z[:, model.n_support + i:model.n_support + i + 1] ], dim=1).view(1, -1, z.size(2)) for i in range(model.n_query) ] # model.n_query is the number of query images for each class # gnn_feature is grouped into n_query groups. each group contains the support image features concatenated with one query image features. # print(len(gnn_feature), gnn_feature[0].shape) gnn_nodes = torch.cat( [torch.cat([z, support_label], dim=2) for z in gnn_feature], dim=0 ) # the features are concatenated with the one hot label. for the unknow image the one hot label is all zero # perform gnn_net step by step # the first iteration print('x', gnn_nodes.shape) W_init = torch.eye( gnn_nodes.size(1), device=gnn_nodes.device ).unsqueeze(0).repeat(gnn_nodes.size(0), 1, 1).unsqueeze( 3 ) # (n_querry, n_way*(num_support + 1), n_way*(num_support + 1), 1) # print(W_init.shape) W1 = gnn_net._modules['layer_w{}'.format(0)]( gnn_nodes, W_init ) # (n_querry, n_way*(num_support + 1), n_way*(num_support + 1), 2) # print(Wi.shape) x_new1 = F.leaky_relu(gnn_net._modules['layer_l{}'.format(0)]( [W1, gnn_nodes])[1]) # (num_querry, num_support + 1, num_outputs) # print(x_new1.shape) #torch.Size([1, 30, 48]) gnn_nodes_1 = torch.cat([gnn_nodes, x_new1], 2) # (concat more features) # print('gn1',gnn_nodes_1.shape) #torch.Size([1, 30, 181]) # the second iteration W2 = gnn_net._modules['layer_w{}'.format(1)]( gnn_nodes_1, W_init ) # (n_querry, n_way*(num_support + 1), n_way*(num_support + 1), 2) x_new2 = F.leaky_relu(gnn_net._modules['layer_l{}'.format(1)]( [W2, gnn_nodes_1])[1]) # (num_querry, num_support + 1, num_outputs) # print(x_new2.shape) gnn_nodes_2 = torch.cat([gnn_nodes_1, x_new2], 2) # (concat more features) # print('gn2', gnn_nodes_2.shape) #torch.Size([1, 30, 229]) Wl = gnn_net.w_comp_last(gnn_nodes_2, W_init) # print(Wl.shape) #torch.Size([1, 30, 30, 2]) scores = gnn_net.layer_last( [Wl, gnn_nodes_2])[1] # (num_querry, num_support + 1, num_way) print(scores.shape) scores_sf = torch.softmax(scores, dim=-1) # print(scores_sf) gnn_logits = torch.log(LRPutil.LOGIT_BETA * scores_sf / (1 - scores_sf)) gnn_logits = gnn_logits.view(-1, model.n_way, model.n_support + n_query, model.n_way) # print(gnn_logits) query_scores = scores.view( model.n_query, model.n_way, model.n_support + 1, model.n_way)[:, :, -1].permute(1, 0, 2).contiguous().view(-1, model.n_way) preds = query_scores.data.cpu().numpy().argmax(axis=-1) # print(preds.shape) for k in range(model.n_way): mask = torch.zeros(5).cuda() mask[k] = 1 gnn_logits_cls = gnn_logits.clone() gnn_logits_cls[:, :, -1] = gnn_logits_cls[:, :, -1] * mask # print(gnn_logits_cls) # print(gnn_logits_cls.shape) gnn_logits_cls = gnn_logits_cls.view(-1, model.n_way) relevance_gnn_nodes_2 = explain_Gconv(gnn_logits_cls, gnn_net.layer_last, Wl, gnn_nodes_2) relevance_x_new2 = relevance_gnn_nodes_2.narrow(-1, 181, 48) # relevance_gnn_nodes = relevance_gnn_nodes_2 relevance_gnn_nodes_1 = explain_Gconv( relevance_x_new2, gnn_net._modules['layer_l{}'.format(1)], W2, gnn_nodes_1) relevance_x_new1 = relevance_gnn_nodes_1.narrow(-1, 133, 48) relevance_gnn_nodes = explain_Gconv( relevance_x_new1, gnn_net._modules['layer_l{}'.format(0)], W1, gnn_nodes) relevance_gnn_features = relevance_gnn_nodes.narrow(-1, 0, 128) print(relevance_gnn_features.shape) relevance_gnn_features += relevance_gnn_nodes_1.narrow(-1, 0, 128) relevance_gnn_features += relevance_gnn_nodes_2.narrow( -1, 0, 128) #[2, 30, 128] relevance_gnn_features = relevance_gnn_features.view( n_query, model.n_way, model.n_support + 1, 128) for i in range(n_query): query_i = relevance_gnn_features[i][:, model. n_support:model.n_support + 1] if i == 0: relevance_z = query_i else: relevance_z = torch.cat((relevance_z, query_i), 1) relevance_z = relevance_z.view(-1, 128) query_feature = x_feature.view(model.n_way, -1, 512)[:, model.n_support:] # print(query_feature.shape) query_feature = query_feature.contiguous() query_feature = query_feature.view(n_query * model.n_way, 512) # print(query_feature.shape) relevance_query_features = fc_encoder.compute_lrp( query_feature, target=relevance_z) # print(relevance_query_features.shape) # print(relevance_gnn_features.shape) # explain the fc layer and the image encoder query_images = x.view(model.n_way, -1, *x.size()[1:])[:, model.n_support:] query_images = query_images.contiguous() query_images = query_images.view(-1, *x.size()[1:]).detach() # print(query_images.shape) lrp_wrapper.add_lrp(feature_model, lrp_preset) relevance_query_images = feature_model.compute_lrp( query_images, target=relevance_query_features) print(relevance_query_images.shape) for j in range(n_query * model.n_way): predict_class = label_to_readableclass[preds[j]] true_class = query_gt_class[int(j % model.n_way)][int( j // model.n_way)] explain_class = label_to_readableclass[k] img_name = query_img_path[int(j % model.n_way)][int( j // model.n_way)].split('/')[-1] if not os.path.isdir( os.path.join(explanation_save_dir, 'episode' + str(batch_idx), img_name.strip('.jpg'))): os.makedirs( os.path.join(explanation_save_dir, 'episode' + str(batch_idx), img_name.strip('.jpg'))) save_path = os.path.join(explanation_save_dir, 'episode' + str(batch_idx), img_name.strip('.jpg')) if not os.path.exists( os.path.join( save_path, true_class + '_' + predict_class + img_name)): original_img = Image.fromarray( np.uint8( project(query_images[j].permute( 1, 2, 0).detach().cpu().numpy()))) original_img.save( os.path.join( save_path, true_class + '_' + predict_class + img_name)) img_relevance = relevance_query_images.narrow(0, j, 1) print(predict_class, true_class, explain_class) # assert relevance_querry_cls[j].sum() != 0 # assert img_relevance.sum()!=0 hm = img_relevance.permute(0, 2, 3, 1).cpu().detach().numpy() hm = LRPutil.gamma(hm) hm = LRPutil.heatmap(hm)[0] hm = project(hm) hp_img = Image.fromarray(np.uint8(hm)) hp_img.save( os.path.join( save_path, true_class + '_' + explain_class + '_lrp_hm.jpg')) break
'segmentation_0_planenet', 'segmentation_0_warping' ] writeHTML(args.test_dir, info_list, numImages=30, convertToImage=False, filename='comparison_segmentation') pass exit(1) pass evaluate(args) if __name__ == '__main__': args = parse_args() if args.dataset == '': args.keyname = 'evaluate' else: args.keyname = args.dataset pass args.test_dir = 'test/' + args.keyname if args.testingIndex >= 0: args.debug = True pass if args.debug: args.test_dir += '_debug' args.printInfo = True pass
pass instance_info = [(mask[:num_ori_coords], label, confidence) for mask, label, confidence in instance_info] instance_pred = instance_pred[:num_ori_coords] semantic_pred = semantic_pred[:num_ori_coords] writeInstances(test_dir, scene_id, instance_pred, semantic_pred, instance_info=instance_info) return if __name__ == '__main__': options = parse_args() options.keyname = 'instance' #args.keyname += '_' + args.dataset if options.suffix != '': options.keyname += '_' + options.suffix pass if options.numScales != 1: options.keyname += '_' + str(options.numScales) pass options.checkpoint_dir = 'checkpoint/' + options.keyname filenames = [] split = options.split