def main(): model = ConvModel(args=None, vocabx=None, vocaby=None) model_path = sys.argv[1] model.load_model(model_path) print model.args run_demo(model)
def evaluation(cfg): logger = logging.getLogger("JigsawPuzzle") if torch.cuda.is_available(): device = "cuda" torch.backends.cudnn.benchmark = True else: device = "cpu" if cfg.dataset == "MNIST": in_c = 1 else: in_c = 3 model = ConvModel(in_c, cfg.pieces, cfg.image_size, cfg.hid_c, cfg.stride, cfg.kernel_size) model.load_state_dict(torch.load(os.path.join(cfg.out_dir, "model.pth"))) model = model.to(device) eval_data = build_dataset(cfg, split="test") loader = DataLoader(eval_data, cfg.batch_size, shuffle=False, num_workers=cfg.num_workers, drop_last=False) with torch.no_grad(): l1_diffs = [] l2_diffs = [] prop_wrongs = [] prop_any_wrongs = [] kendall_taus = [] logger.info("start evaluation") for data in loader: inputs, _ = data pieces, random_pieces, perm_index = batch_tch_divide_image(inputs, cfg.pieces) pieces, random_pieces = pieces.to(device), random_pieces.to(device) log_alpha = model(random_pieces) gumbel_matching_mat = gumbel_sinkhorn_ops.gumbel_matching(log_alpha, noise=False) hard_sorted_pieces = gumbel_sinkhorn_ops.inverse_permutation_for_image(random_pieces, gumbel_matching_mat) est_perm_index = gumbel_matching_mat.max(1)[1].float() hard_l1_diff = (pieces - hard_sorted_pieces).abs().mean((2,3,4)) # (batchsize, num_pieces) hard_l2_diff = (pieces - hard_sorted_pieces).pow(2).mean((2,3,4)) sign_l1_diff = hard_l1_diff.sign() prop_wrong = sign_l1_diff.mean(1) prop_any_wrong = sign_l1_diff.sum(1).sign() np_perm_index = perm_index.detach().numpy() np_est_perm_index = est_perm_index.to("cpu").numpy() kendall_tau = metric.kendall_tau(np_est_perm_index, np_perm_index) l1_diffs.append(hard_l1_diff); l2_diffs.append(hard_l2_diff) prop_wrongs.append(prop_wrong); prop_any_wrongs.append(prop_any_wrong) kendall_taus.append(kendall_tau) mean_l1_diff = torch.cat(l1_diffs).mean() mean_l2_diff = torch.cat(l2_diffs).mean() mean_prop_wrong = torch.cat(prop_wrongs).mean() mean_prop_any_wrong = torch.cat(prop_any_wrongs).mean() mean_kendall_tau = np.concatenate(kendall_taus).mean() logger.info("\nmean l1 diff : %f\n mean l2 diff : %f\n mean prop wrong : %f\n mean prop any wrong : %f\n mean kendall tau : %f", mean_l1_diff, mean_l2_diff, mean_prop_wrong, mean_prop_any_wrong, mean_kendall_tau )
def create_predictor(dataset, model_config, model_params, batch_size): x = T.matrix('x') y = T.imatrix('y') drop = T.iscalar('drop') index = T.lscalar() model = ConvModel(model_config, verbose=True) model.build(x, drop, batch_size, init_params=model_params) return create_output_func(dataset, x, y, drop, [index], model.get_output_layer(), batch_size)
def create_simple_predictor(model_config, model_params): #TODO: Does this single predictor even work? data = T.matrix('data') x = T.matrix('x') drop = T.iscalar('drop') batch_size = 1 model = ConvModel(model_config, verbose=True) model.build(x, drop, batch_size, init_params=model_params) return model.create_predict_function(x, drop, data)
def train(cfg): logger = logging.getLogger("JigsawPuzzle") if torch.cuda.is_available(): device = "cuda" torch.backends.cudnn.benchmark = True else: device = "cpu" if cfg.dataset == "MNIST": in_c = 1 else: in_c = 3 train_data = build_dataset(cfg, "train") model = ConvModel(in_c, cfg.pieces, cfg.image_size, cfg.hid_c, cfg.stride, cfg.kernel_size).to(device) optimizer = optim.Adam(model.parameters(), cfg.lr, eps=1e-8) train_loader = DataLoader(train_data, cfg.batch_size, shuffle=True, num_workers=cfg.num_workers, drop_last=True) logger.info("start training") for epoch in range(1, cfg.epochs+1): sum_loss = 0 for i, data in enumerate(train_loader): inputs, _ = data pieces, random_pieces, _ = batch_tch_divide_image(inputs, cfg.pieces) pieces, random_pieces = pieces.to(device), random_pieces.to(device) log_alpha = model(random_pieces) gumbel_sinkhorn_mat = [ gumbel_sinkhorn_ops.gumbel_sinkhorn(log_alpha, cfg.tau, cfg.n_sink_iter) for _ in range(cfg.n_samples) ] est_ordered_pieces = [ gumbel_sinkhorn_ops.inverse_permutation_for_image(random_pieces, gs_mat) for gs_mat in gumbel_sinkhorn_mat ] loss = sum([ torch.nn.functional.mse_loss(X, pieces) for X in est_ordered_pieces ]) optimizer.zero_grad() loss.backward() optimizer.step() sum_loss += loss.item() if cfg.display > 0 and ((i+1) % cfg.display) == 0: logger.info("epoch %i [%i/%i] loss %f", epoch, i+1, len(train_loader), loss.item()) logger.info("epoch %i| mean loss %f", epoch, sum_loss/len(train_loader)) torch.save(model.state_dict(), os.path.join(cfg.out_dir, "model.pth"))
def main(): model = ConvModel( args = None, vocabx = None, vocaby = None ) model_path = sys.argv[1] model.load_model(model_path) print model.args run_demo(model)
def run_cnn(model_params, optimization_params, dataset_path, dataset_params, filename_params, visual_params, epochs, verbose=False): print(filename_params) if not os.path.exists(filename_params.results): os.makedirs(filename_params.results) is_config, config_values = interface.command.get_command("-config") is_curriculum, curriculum_set = interface.command.get_command( "-curriculum") is_batch_run, batch_index = interface.command.get_command("-batch", default="0") is_init_params, param_path = interface.command.get_command("-params") if is_config: #Assume config is speficially for running bootstrapping batches. config_arr = eval(config_values) if len(config_arr) == 2: loss_function = config_arr[0] label_noise = float(config_arr[1]) dataset_params.label_noise = label_noise model_params.loss = loss_function batch_index = loss_function + "-" + str( label_noise) + "-" + batch_index print(batch_index) if is_curriculum: dataset_path = curriculum_set weights = None if is_init_params: store = ParamStorage() if not param_path: param_path = "./results/params.pkl" weights = store.load_params(path=param_path)['params'] dataset = DataLoader.create() dataset.load(dataset_path, dataset_params, optimization_params.batch_size) #Input stage model = ConvModel(model_params, verbose=True) #Create network stage evaluator = Evaluator(model, dataset, optimization_params, dataset_path) evaluator.run(epochs=epochs, verbose=verbose, init=weights) report = evaluator.get_result() network_store_path = filename_params.network_save_name result_path = filename_params.results + "/results.json" if is_batch_run: network_store_path = filename_params.results + "/batch" + batch_index + ".pkl" result_path = filename_params.results + "/batch" + batch_index + ".json" storage = ParamStorage(path=network_store_path) storage.store_params(model.params) dataset.destroy() if visual_params.gui_enabled: interface.server.stop_job(report) printing.print_section('Evaluation precision and recall') prc = PrecisionRecallCurve(pr_path, model.params, model_params, dataset_params) test_datapoints = prc.get_curves_datapoints(optimization_params.batch_size, set_name="test") valid_datapoints = prc.get_curves_datapoints( optimization_params.batch_size, set_name="valid") #Stores the model params. Model can later be restored. printing.print_section('Storing model parameters') if visual_params.gui_enabled: interface.server.send_precision_recall_data(test_datapoints, valid_datapoints) storage.store_result(result_path, evaluator.events, test_datapoints, valid_datapoints)
except: parser.print_help() sys.exit(0) # data_loader를 이용해서 전체 데이터셋 가져옴 DATASET_PATH = './data' extern_data = [] # 가져온 문장별 데이터셋을 이용해서 각종 정보 및 학습셋 구성 dataset = Dataset(parameter, extern_data) dev_dataset = Dataset(parameter, extern_data) # Model 불러오기 if parameter["use_conv_model"]: model = ConvModel(dataset.parameter) print("[Use Conv with lstm...]") else: model = Model(dataset.parameter) print("[Use original lstm...]") model.build_model() # tensorflow session 생성 및 초기화 sess = tf.Session() sess.run(tf.global_variables_initializer()) # 학습 if parameter["mode"] == "train": extern_data = data_loader(DATASET_PATH) # random.shuffle(extern_data) # shuffle input data
es, f2i = load_sentences(args.test, embeddings.vocab, f2i, args.clean, args.chars, args.mxlen, mxfiltsz, vec_alloc=long_0_tensor_alloc2, ExType=TorchExamples) print('Loaded test data') nc = len(f2i) mdsave(f2i, embeddings.vocab, args.outdir, args.save) model = ConvModel(embeddings, nc, args.filtsz, args.cmotsz, args.hsz, args.dropout, not args.static) trainer = Trainer(gpu, model, args.optim, args.eta, args.mom) max_acc = 0 last_improved = 0 for i in range(args.epochs): print('Training epoch %d' % (i + 1)) trainer.train(ts, args.batchsz) this_acc = trainer.test(vs, args.batchsz, 'Validation') if this_acc > max_acc: max_acc = this_acc last_improved = i model.save(args.outdir, args.save) print('Highest dev acc achieved yet -- writing model')
if not os.path.exists('./ckpt/'): os.makedirs('./ckpt/') if not os.path.exists('./iter_num/' + args.model_name): os.makedirs('./iter_num/' + args.model_name) if not os.path.exists('./logs/' + args.model_name): os.makedirs('./logs/' + args.model_name) if not os.path.exists('./labels/' + args.model_name): os.makedirs('./labels/' + args.model_name) if not os.path.exists('./c/'): os.makedirs('./c/') dataset = Dataset(args) change_itr = range(8000, 100000, 4000) logger = Logger('./logs/' + args.model_name) if args.env_name == 'bimgame': model = ConvModel(3, args.num_subgoals, use_rnn=False).to(device) else: model = MLPModel(46, args.num_subgoals, use_rnn=False).to(device) start_itr = 0 c = [] if args.one_class: if args.pretrained_ckpt is not None: model.load_state_dict( torch.load('./ckpt/' + args.pretrained_ckpt + '.pkl')) start_itr = np.load('./iter_num/' + args.pretrained_ckpt + '.npy') c = torch.from_numpy( np.load('./c/' + args.pretrained_ckpt + '.npy')).float().to(device) # computing initial c for one-class out-of-set estimation if len(c) == 0:
parser.add_argument('--max_sentence_len', type=int, default=20, help='maximum sentence length') parser.add_argument('--data_n_samples', type=int, default=100, help='number of samples per color, shape combination') args = parser.parse_args() images_dict = load_images_dict(args.data_n_samples) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") agent1 = ConvModel(vocab_size=args.vocab_size).to(device) agent2 = ConvModel(vocab_size=args.vocab_size).to(device) loss_fn = NLLLoss() optimizer1 = torch.optim.Adam( [p for p in agent1.parameters() if p.requires_grad], args.lr) optimizer2 = torch.optim.Adam( [p for p in agent2.parameters() if p.requires_grad], args.lr) def get_message(s): return ''.join( [chr(97 + int(v.cpu().data)) for v in s if v < args.vocab_size])
import numpy as np import torch.nn as nn import torch from model import ConvModel device = torch.device('cpu') M = 1 Tx = 50 model = ConvModel().to(device)
int(len(all_split) * 0.8):] dataloader = DataLoader(train_set, batch_size=batch_size, num_workers=n_cpu, sampler=RandomSampler(train_split)) valid_dataloader = DataLoader(train_set, batch_size=batch_size, num_workers=n_cpu, sampler=RandomSampler(val_split)) if load_model: with open(load_model_path, 'rb') as f: net = log.load_model().to(device) else: net = ConvModel(1024, 2).to(device) optimizer = torch.optim.Adam(net.parameters()) loss_func = F.binary_cross_entropy print('start trainning ......') for e in range(epochs): net.train() for i, batchs in enumerate(dataloader): sig, other, label = batchs['sig'].to(device), batchs['other'].to( device), batchs['label'].to(device) out = net(sig, other) loss = loss_func(out, label) optimizer.zero_grad()