def make_submission(cfg): predictions = [] # setting dataset --------------------------- loader_test = dataset_factory.get_dataloader(cfg.data.test) ## model ------------------------------------ model = model_factory.get_model(cfg) util.load_model(model_paths[0], model) model.to(device) model.eval() train_df = pd.read_csv(cfg.train_csv) regr_model = kaggle.get_regr_model(train_df) for img, _, _ in tqdm(loader_test): with torch.no_grad(): output = model(img.to(device)) output = output.data.cpu().numpy() for out in output: coords = kaggle.extract_coords(out, regr_model) s = kaggle.coords2str(coords) predictions.append(s) test = pd.read_csv(cfg.data.test.dataframe) test['PredictionString'] = predictions test.to_csv('predictions.csv', index=False) log.info(test.head())
def load_net(img, hde_arr, model, weight_path, device): model.to(device) util.load_model(model, weight_path) hde_distance = model(img, hde_arr) return hde_distance
def run(): queries_folder = '/media/alberto/DATA/ExperimentalCollections/Robust04/processed/topics' documents_folder = '/media/alberto/DATA/ExperimentalCollections/Robust04/processed/corpus' stop_word_path = '/home/alberto/PycharmProjects/probabilisticir/indri_stoplist_eng.txt' gt_file = '/media/alberto/DATA/ExperimentalCollections/Robust04/processed/qrels.robust2004.txt' run_to_rerank = '/home/alberto/PycharmProjects/probabilisticir/robust.terrier.krovetz.qld.2k.run' queries, query_names = input_output.load_texts(queries_folder, stop_word_path) # documents, doc_names = input_output.load_texts(documents_folder, stop_word_path) # idf_scores, word_index = input_output.compute_idf(documents, 10, 0.5) # util.save_json(word_index, 'word_index_json') idf_scores = util.load_model('idf_scores') word_index = util.load_json('word_index_json') encoded_idf_scores = { word_index[k]: v for k, v in idf_scores.items() if k in word_index.keys() } # encoded_docs = [[word_index[w] for w in d if w in word_index.keys()] for d in documents] # encoded_queries = [[word_index[w] for w in q if w in word_index.keys()] for q in queries] # util.save_model(encoded_docs, 'encoded_docs') # util.save_model(encoded_queries, 'encoded_queries') # util.save_model(query_names, 'q_names') # util.save_model(doc_names, 'd_names') query_names = util.load_model('q_names') doc_names = util.load_model('d_names') # query_names = util.load_model('q_names') # doc_names = util.load_model('d_names') query_names = [n.split(r'.txt')[0] for n in query_names][:50] doc_names = [n.split(r'.txt')[0] for n in doc_names] encoded_queries = util.load_model('encoded_queries')[:50] encoded_docs = util.load_model('encoded_docs') evaluate_ranking(encoded_idf_scores, encoded_queries, encoded_docs, query_names, doc_names, gt_file, run_to_rerank)
def save_mask_multiprocess(num, data_size): process_id = os.getpid() print('process {} starts...'.format(process_id)) if args.num_gpu == 1: gpu_id = args.gpu_id elif args.num_gpu == 2: if num >= data_size // args.num_gpu: gpu_id = args.gpu_id + 0 else: gpu_id = args.gpu_id + 1 elif args.num_gpu == 4: if num >= data_size // args.num_gpu * 3: gpu_id = args.gpu_id + 0 elif num >= data_size // args.num_gpu * 2: gpu_id = args.gpu_id + 1 elif num >= data_size // args.num_gpu * 1: gpu_id = args.gpu_id + 2 else: gpu_id = args.gpu_id + 3 else: raise Exception("ERROR") base_model = models.__dict__[args.arch](num_classes=21) model = base_model model = load_model(model, args.trained) model = model.cuda(gpu_id) model.eval() if num == data_size - 1: sub_image_ids = image_ids[num * len(image_ids) // data_size:] else: sub_image_ids = image_ids[num * len(image_ids) // data_size: (num + 1) * len(image_ids) // data_size] if num == 0: print(len(sub_image_ids), 'images per each process...') for idx, img_id in enumerate(sub_image_ids): if num == 0 and idx % 10 == 0: print("[{0} * {3}]/[{1} * {3}] : {2} is done.".format(idx, len(sub_image_ids), img_id, args.split_size)) image_file = os.path.join(image_path, img_id + '.jpg') cls_label = cls_list[img_id] if args.color_mask: output, pred = predict_color_mask(image_file, model, args.smooth, gpu_id, cls_label) save_path = os.path.join(args.pred_path, "output" ,img_id + '_output.png') cv2.imwrite(save_path, cv2.cvtColor(output, cv2.COLOR_RGB2BGR)) save_path = os.path.join(args.pred_path, "pred", img_id + '_pred.png') cv2.imwrite(save_path, cv2.cvtColor(pred, cv2.COLOR_RGB2BGR)) else: labelmap = predict_label_mask(image_file, model, args.smooth, gpu_id) save_path = os.path.join(args.pred_path, "label_mask" ,img_id + '_labelmask.png') cv2.imwrite(save_path, labelmap)
def initialize_from_saved_model(args): print('Training on saved model') if args.device is not None: os.environ["CUDA_VISIBLE_DEVICES"] = str(args.device) model, optimizer, epoch = load_model(args) train_loader = COVIDxDataset(mode='train', n_classes=args.classes, dataset_path=args.dataset, dim=(224, 224)) #print(train_loader.) #------ Class weigths for sampling and for loss function ----------------------------------- labels = np.unique(train_loader.labels) #print(labels) class_weight = compute_class_weight('balanced', labels, train_loader.labels) class_weight = class_weight[::-1] #class_weight[2]=50 #weights = torch.DoubleTensor(class_weight.copy()) #sampler = torch.utils.data.sampler.WeightedRandomSampler(weights, len(train_loader.labels)) if (args.cuda): class_weight = torch.from_numpy(class_weight.astype(float)).cuda() else: class_weight = torch.from_numpy(class_weight.astype(float)) #print(class_weight.shape) #------------------------------------------- val_loader = COVIDxDataset(mode='test', n_classes=args.classes, dataset_path=args.dataset, dim=(224, 224)) #------------------------------------------------------------------------------------ train_params = { 'batch_size': args.batch_size, 'shuffle': True, 'num_workers': 4 } #'sampler' : sampler test_params = { 'batch_size': args.batch_size, 'shuffle': False, 'num_workers': 4 } #------------------------------------------------------------------------------------------ training_generator = DataLoader(train_loader, **train_params) val_generator = DataLoader(val_loader, **test_params) return model, optimizer, training_generator, val_generator, class_weight, epoch
def save_mask_multiprocess(num, data_size): process_id = os.getpid() print('process {} starts...'.format(process_id)) if args.num_gpu == 1: gpu_id = args.gpu_id elif args.num_gpu == 2: if num >= data_size // args.num_gpu: gpu_id = args.gpu_id + 0 else: gpu_id = args.gpu_id + 1 elif args.num_gpu == 4: if num >= data_size // args.num_gpu * 3: gpu_id = args.gpu_id + 0 elif num >= data_size // args.num_gpu * 2: gpu_id = args.gpu_id + 1 elif num >= data_size // args.num_gpu * 1: gpu_id = args.gpu_id + 2 else: gpu_id = args.gpu_id + 3 else: raise Exception("ERROR") model = models.__dict__[args.arch](21) model = model.cuda(gpu_id) model = load_model(model, args.trained) model.eval() if num == data_size - 1: sub_image_ids = image_ids[num * len(image_ids) // data_size:] else: sub_image_ids = image_ids[num * len(image_ids) // data_size: (num + 1) * len(image_ids) // data_size] if num == 0: print(len(sub_image_ids), 'images per each process...') for idx, img_id in enumerate(sub_image_ids): if num == 0 and idx % 10 == 0: print("[{0} * {3}]/[{1} * {3}] : {2} is done.".format(idx, len(sub_image_ids), img_id, args.split_size)) image_file = os.path.join(image_path, img_id + '.jpg') mask = predict_mask(image_file, model, args.smooth, gpu_id) save_path = os.path.join(args.pred_path, img_id + '.png') cv2.imwrite(save_path, mask)
def __init__(self, bb, image_data, plot, args, nn_fname=''): # Pretrained Kernel (for Sliders) # kernel = ConstantKernel(0.005, constant_value_bounds=(0.005, 0.005)) * RBF(length_scale=(0.247, 0.084, 0.0592), length_scale_bounds=(0.0592, 0.247)) + WhiteKernel(noise_level=1e-5, noise_level_bounds=(1e-5, 1e2)) # Pretrained Kernel (for Doors) # 0.0202**2 * RBF(length_scale=[0.0533, 0.000248, 0.0327, 0.0278]) + WhiteKernel(noise_level=1e-05) self.xs, self.ys, self.moves = {'Prismatic': [], 'Revolute': []}, \ {'Prismatic': [], 'Revolute': []}, \ {'Prismatic': [], 'Revolute': []} self.plot = plot self.nn = None if nn_fname != '': self.nn = util.load_model(nn_fname, args.hdim, use_cuda=False) self.bb = bb self.image_data = image_data self.mech = self.bb._mechanisms[0] self.gps = {'Prismatic': GaussianProcessRegressor(kernel=self.get_kernel('Prismatic'), #args.type), n_restarts_optimizer=1), 'Revolute': GaussianProcessRegressor(kernel=self.get_kernel('Revolute'), #args.type), n_restarts_optimizer=1)} self.optim = GPOptimizer(args.urdf_num, self.bb, self.image_data, \ args.n_gp_samples, BETA, self.gps, nn=self.nn)
def train(args): #prepare_data_loaders(configs) cuda = torch.device('cuda') step = 0 loss_list = list() plt.rc('font', family='Malgun Gothic') model = Model(configs).cuda() optimizer = torch.optim.Adam(model.parameters(), lr=1e-5) if args.load != '': model, optimizer, step = util.load_model(args.load, model, optimizer) util.mkdir(args.save) for epoch in range(100): train_data_loader, valid_data_loader = get_data_loaders(configs) for i, data in tqdm(enumerate(train_data_loader), total=int( len(train_data_loader.dataset) / train_data_loader.batch_size)): step += 1 path_list, mel_batch, encoded_batch, text_list, mel_length_list, encoded_length_list = data # mel_out, stop_tokens = model(torch.tensor(encoded_batch), torch.tensor(mel_batch)) mel_out, stop_tokens, enc_attention, dec_attention = model( encoded_batch, mel_batch) loss = nn.L1Loss()(mel_out.cuda(), mel_batch.cuda()) loss_list.append(loss.item()) if step % LOGGING_STEPS == 0: writer.add_scalar('loss', np.mean(loss_list), step) writer.add_text('script', text_list[0], step) # writer.add_image('mel_in', torch.transpose(mel_batch[:1], 1, 2), step) # (1, 80, T) # writer.add_image('mel_out', torch.transpose(mel_out[:1], 1, 2), step) # (1, 80, T) #attention_image = matrix_to_plt_image(enc_attention[0].cpu().detach().numpy().T, text_list[0]) #writer.add_image('attention', attention_image, step, dataformats="HWC") for i, prob in enumerate(enc_attention): for j in range(4): x = torchvision.utils.make_grid(prob[j * 4] * 255) writer.add_image('ENC_Attention_%d_0' % step, x, step) print(dec_attention[0].shape) for i, prob in enumerate(dec_attention): for j in range(4): x = torchvision.utils.make_grid(prob[j * 4] * 255) writer.add_image('DEC_Attention_%d_0' % step, x, step) image = matrix_to_plt_image( mel_batch[0].cpu().detach().numpy().T, text_list[0]) writer.add_image('mel_in', image, step, dataformats="HWC") # (1, 80, T) image = matrix_to_plt_image( mel_out[0].cpu().detach().numpy().T, text_list[0]) writer.add_image('mel_out', image, step, dataformats="HWC") # (1, 80, T) # print(torch.min(mel_batch), torch.max(mel_batch)) # print(torch.min(mel_out), torch.max(mel_out)) # AssertionError: size of input tensor and input format are different. # tensor shape: (578, 80), input_format: CHW # print(mel_batch.shape) # print(mel_out.shape) # torch.Size([24, 603, 80]) # B = 24 # print(attn_dot_list[0].shape) # torch.Size([96, 603, 603]) # 96 = B * 4 (num att. heads) # print(attn_dec_list[0].shape) # torch.Size([96, 603, 603]) # https://tutorials.pytorch.kr/intermediate/tensorboard_tutorial.html # https://www.tensorflow.org/tensorboard/image_summaries util.save_model(model, optimizer, args.save, step) loss_list = list() # print(nn.L1Loss()(mel_out.cuda(), mel_batch.cuda()).item()) optimizer.zero_grad() loss.backward() # YUNA! Do not miss the gradient update! # https://tutorials.pytorch.kr/beginner/pytorch_with_examples.html optimizer.step() # break loss_list_test = list() for i, data in tqdm(enumerate(valid_data_loader), total=int( len(valid_data_loader.dataset) / valid_data_loader.batch_size)): path_list, mel_batch, encoded_batch, text_list, mel_length_list, encoded_length_list = data mel_out, stop_tokens = model(encoded_batch, mel_batch) loss = nn.L1Loss()(mel_out.cuda(), mel_batch.cuda()) loss_list_test.append(loss.item()) writer.add_scalar('loss_valid', np.mean(loss_list), step) writer.add_text('script_valid', text_list[0], step) image = matrix_to_plt_image(mel_batch[0].cpu().detach().numpy().T, text_list[0]) writer.add_image('mel_in_valid', image, step, dataformats="HWC") # (1, 80, T) image = matrix_to_plt_image(mel_out[0].cpu().detach().numpy().T, text_list[0]) writer.add_image('mel_out_valid', image, step, dataformats="HWC") # (1, 80, T) loss_list_test = list() for i, data in tqdm(enumerate(valid_data_loader), total=int( len(valid_data_loader.dataset) / valid_data_loader.batch_size)): path_list, mel_batch, encoded_batch, text_list, mel_length_list, encoded_length_list = data zero_batch = torch.zeros_like(mel_batch) mel_out, stop_tokens = model(encoded_batch, zero_batch) loss = nn.L1Loss()(mel_out.cuda(), mel_batch.cuda()) loss_list_test.append(loss.item()) writer.add_scalar('loss_infer', np.mean(loss_list), step) writer.add_text('script_infer', text_list[0], step) image = matrix_to_plt_image(mel_batch[0].cpu().detach().numpy().T, text_list[0]) writer.add_image('mel_in_infer', image, step, dataformats="HWC") # (1, 80, T) image = matrix_to_plt_image(mel_out[0].cpu().detach().numpy().T, text_list[0]) writer.add_image('mel_out_infer', image, step, dataformats="HWC") # (1, 80, T) # break # torch.save(model, PATH) return
batch_size=args.batch, shuffle=True, num_workers=4, drop_last=False) loader_val = DataLoader(dataset_val, batch_size=args.batch, shuffle=True, num_workers=4, drop_last=False) loader_seg = DataLoader(dataset_seg, batch_size=args.batch, shuffle=True, num_workers=4, drop_last=False) model = util.load_model('rgb', device, args.ckpt, args.img_size) if args.ckpt is not None: print('Resuming training...') model.train() optimizer = optim.Adam(model.parameters(), lr=args.lr) scheduler = None if args.sched == 'cycle': scheduler = CycleScheduler(optimizer, args.lr, n_iter=len(loader) * args.epoch, momentum=None) current_best = 999999 for i in range(args.epoch): train(i, loader_train, loader_seg, model, optimizer, scheduler, device, args.img_size)
def main(): args = get_args() if args.gpu is not None: print("Use GPU: {} for training".format(args.gpu)) # number of classes for each dataset. if args.dataset == 'PascalVOC': num_classes = 20 else: raise Exception("No dataset named {}.".format(args.dataset)) # Select Model & Method model = models.__dict__[args.arch](pretrained=args.pretrained, num_classes=num_classes) if args.gpu is not None: torch.cuda.set_device(args.gpu) model = model.cuda(args.gpu) # define loss function (criterion) and optimizer criterion = nn.MultiLabelSoftMarginLoss().cuda(args.gpu) # criterion = nn.BCEWithLogitsLoss().cuda(args.gpu) # Take apart parameters to give different Learning Rate param_features = [] param_classifiers = [] if args.arch.startswith('vgg'): for name, parameter in model.named_parameters(): if 'features.' in name: param_features.append(parameter) else: param_classifiers.append(parameter) elif args.arch.startswith('resnet'): for name, parameter in model.named_parameters(): if 'layer4.' in name or 'fc.' in name: param_classifiers.append(parameter) else: param_features.append(parameter) else: raise Exception("Fail to recognize the architecture") # Optimizer optimizer = torch.optim.SGD([ {'params': param_features, 'lr': args.lr}, {'params': param_classifiers, 'lr': args.lr * args.lr_ratio}], momentum=args.momentum, weight_decay=args.weight_decay, nesterov=args.nest) # optionally resume from a checkpoint if args.resume: model, optimizer = load_model(model, optimizer, args) train_loader, val_loader, test_loader = data_loader(args) saving_dir = os.path.join(args.log_folder, args.name) if args.evaluate: # test_ap, test_loss = evaluate_cam(val_loader, model, criterion, args) # test_ap, test_loss = evaluate_cam2(val_loader, model, criterion, args) test_ap, test_loss = evaluate_cam3(val_loader, model, criterion, args) print_progress(test_ap, test_loss, 0, 0, prefix='test') return # Training Phase best_m_ap = 0 for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch, args) # Train for one epoch train_ap, train_loss = \ train(train_loader, model, criterion, optimizer, epoch, args) print_progress(train_ap, train_loss, epoch+1, args.epochs) # Evaluate classification val_ap, val_loss = validate(val_loader, model, criterion, epoch, args) print_progress(val_ap, val_loss, epoch+1, args.epochs, prefix='validation') # # Save checkpoint at best performance: is_best = val_ap.mean() > best_m_ap if is_best: best_m_ap = val_ap.mean() save_checkpoint({ 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_m_ap': best_m_ap, 'optimizer': optimizer.state_dict(), }, is_best, saving_dir) save_progress(saving_dir, train_ap, train_loss, val_ap, val_loss, args)
def load_w2v_model(wi_path, we_path): we = util.load_model(we_path) wi = util.load_model(wi_path) return we, wi
def do_train(cfg, model): # get criterion ----------------------------- criterion = criterion_factory.get_criterion(cfg) # get optimization -------------------------- optimizer = optimizer_factory.get_optimizer(model, cfg) # initial ----------------------------------- best = { 'loss': float('inf'), 'score': 0.0, 'epoch': -1, } # resume model ------------------------------ if cfg.resume_from: log.info('\n') log.info(f're-load model from {cfg.resume_from}') detail = util.load_model(cfg.resume_from, model, optimizer, cfg.device) best.update({ 'loss': detail['loss'], 'score': detail['score'], 'epoch': detail['epoch'], }) # scheduler --------------------------------- scheduler = scheduler_factory.get_scheduler(cfg, optimizer, best['epoch']) # fp16 -------------------------------------- if cfg.apex: amp.initialize(model, optimizer, opt_level='O1', verbosity=0) # setting dataset --------------------------- loader_train = dataset_factory.get_dataloader(cfg.data.train) loader_valid = dataset_factory.get_dataloader(cfg.data.valid) # start trainging --------------------------- start_time = datetime.now().strftime('%Y/%m/%d %H:%M:%S') log.info('\n') log.info(f'** start train [fold{cfg.fold}th] {start_time} **\n') log.info( 'epoch iter rate | smooth_loss/score | valid_loss/score | best_epoch/best_score | min' ) log.info( '-------------------------------------------------------------------------------------------------' ) for epoch in range(best['epoch'] + 1, cfg.epoch): end = time.time() util.set_seed(epoch) ## train model -------------------------- train_results = run_nn(cfg.data.train, 'train', model, loader_train, criterion=criterion, optimizer=optimizer, apex=cfg.apex, epoch=epoch) ## valid model -------------------------- with torch.no_grad(): val_results = run_nn(cfg.data.valid, 'valid', model, loader_valid, criterion=criterion, epoch=epoch) detail = { 'score': val_results['score'], 'loss': val_results['loss'], 'epoch': epoch, } if val_results['loss'] <= best['loss']: best.update(detail) util.save_model(model, optimizer, detail, cfg.fold[0], os.path.join(cfg.workdir, 'checkpoint')) log.info('%5.1f %5d %0.6f | %0.4f %0.4f | %0.4f %6.4f | %6.1f %6.4f | %3.1f min' % \ (epoch+1, len(loader_train), util.get_lr(optimizer), train_results['loss'], train_results['score'], val_results['loss'], val_results['score'], best['epoch'], best['score'], (time.time() - end) / 60)) scheduler.step( val_results['loss']) # if scheduler is reducelronplateau # scheduler.step() # early stopping------------------------- if cfg.early_stop: if epoch - best['epoch'] > cfg.early_stop: log.info(f'=================================> early stopping!') break time.sleep(0.01)
import os from utils.metric import evaluate from utils.data_container import get_data_loader from utils.load_config import get_attribute from utils.util import convert_to_gpu from train.train_main import create_model from utils.util import load_model if __name__ == '__main__': model_path = f"../save_model_folder/{get_attribute('data')}/{get_attribute('save_model_folder')}" \ f"/model_epoch_19.pkl" print(f'model path -> {model_path}') model = create_model() model = load_model(model, model_path) model = convert_to_gpu(model) print(model) test_data_loader = get_data_loader( data_path=get_attribute('data_path'), data_type='test', batch_size=get_attribute('batch_size'), item_embedding_matrix=model.item_embedding) print('===== Test predict result =====') scores = evaluate(model, test_data_loader) scores = sorted(scores.items(), key=lambda item: item[0], reverse=False) scores = {item[0]: item[1] for item in scores}
vectors = torch.cat([vectors, vectors[0].unsqueeze(0)], 0) vectors = torch.cat([vectors, vectors[0].unsqueeze(0)], 0) vectors[0] = torch.zeros(dim) n_words = len(vectors) n_rel = len(r2id) rel_emb = torch.from_numpy(np.loadtxt(args.rel_kg_vec)) ent_cand_s = 100 model = E2E_entity_linker(num_words=n_words, emb_dim=dim, hidden_size=args.hidden_size, num_layers=args.num_layer, emb_dropout=args.emb_drop, pretrained_emb=vectors, train_embed=False, kg_emb_dim=50, rel_size=n_rel, ent_cand_size=ent_cand_s, pretrained_rel=rel_emb, dropout=args.rnn_dropout, use_cuda=args.gpu) model = load_model(model, model_name, gpu=args.gpu) model.eval() def interact(question): question = clean_str(question) if question!="": wikiid,elabel,predfb = infer(question,model, e2id=e2id, e_1hop=e_1hop, stoi=stoi) return wikiid, elabel, predfb else: print("Please ask something !!") return "","","" @app.route('/elidi') def home(): return render_template('index.html')
def main(): args = get_args() log_folder = os.path.join('train_log', args.name) writer = SummaryWriter(log_folder) if args.gpu is not None: print("Use GPU: {} for training".format(args.gpu)) # number of classes for each dataset. if args.dataset == 'PascalVOC': num_classes = 21 elif args.dataset == 'COCO': num_classes = 81 else: raise Exception("No dataset named {}.".format(args.dataset)) # Select Model & Method model = models.__dict__[args.arch](num_classes=num_classes) if args.gpu is not None: torch.cuda.set_device(args.gpu) model = model.cuda(args.gpu) # Optimizer optimizer = torch.optim.SGD( [{ 'params': get_parameters(model, bias=False, final=False), 'lr': args.lr, 'weight_decay': args.wd }, { 'params': get_parameters(model, bias=True, final=False), 'lr': args.lr * 2, 'weight_decay': 0 }, { 'params': get_parameters(model, bias=False, final=True), 'lr': args.lr * 10, 'weight_decay': args.wd }, { 'params': get_parameters(model, bias=True, final=True), 'lr': args.lr * 20, 'weight_decay': 0 }], momentum=args.momentum) if args.resume: model = load_model(model, args.resume) train_loader = data_loader(args) data_iter = iter(train_loader) train_t = tqdm(range(args.max_iter)) model.train() for global_iter in train_t: try: images, target, gt_map = next(data_iter) except: data_iter = iter(data_loader(args)) images, target, gt_map = next(data_iter) if args.gpu is not None: images = images.cuda(args.gpu) gt_map = gt_map.cuda(args.gpu) target = target.cuda(args.gpu) output = model(images) fc8_SEC_softmax = softmax_layer(output) loss_s = seed_loss_layer(fc8_SEC_softmax, gt_map) loss_e = expand_loss_layer(fc8_SEC_softmax, target, num_classes - 1) fc8_SEC_CRF_log = crf_layer(output, images, iternum=10) loss_c = constrain_loss_layer(fc8_SEC_softmax, fc8_SEC_CRF_log) loss = loss_s + loss_e + loss_c optimizer.zero_grad() loss.backward() optimizer.step() # writer add_scalars writer.add_scalar('loss', loss, global_iter) writer.add_scalars('losses', { 'loss_s': loss_s, 'loss_e': loss_e, 'loss_c': loss_c }, global_iter) with torch.no_grad(): if global_iter % 10 == 0: # writer add_images (origin, output, gt) origin = images.clone().detach() + torch.tensor( [123., 117., 107.]).reshape(1, 3, 1, 1).cuda(args.gpu) size = (100, 100) origin = F.interpolate(origin, size=size) origins = vutils.make_grid(origin, nrow=15, padding=2, normalize=True, scale_each=True) outputs = F.interpolate(output, size=size) _, outputs = torch.max(outputs, dim=1) outputs = outputs.unsqueeze(1) outputs = vutils.make_grid(outputs, nrow=15, padding=2, normalize=True, scale_each=True).float() gt_maps = F.interpolate(gt_map, size=size) _, gt_maps = torch.max(gt_maps, dim=1) gt_maps = gt_maps.unsqueeze(1) gt_maps = vutils.make_grid(gt_maps, nrow=15, padding=2, normalize=True, scale_each=True).float() # gt_maps = F.interpolate(gt_map.unsqueeze(1).float(), size=size) # gt_maps = vutils.make_grid(gt_maps, nrow=15, padding=2, normalize=True, scale_each=True).float() grid_image = torch.cat((origins, outputs, gt_maps), dim=1) writer.add_image(args.name, grid_image, global_iter) description = '[{0:4d}/{1:4d}] loss: {2} s: {3} e: {4} c: {5}'.\ format(global_iter+1, args.max_iter, loss, loss_s, loss_e, loss_c) train_t.set_description(desc=description) # save snapshot if global_iter % args.snapshot == 0: save_checkpoint(model.state_dict(), log_folder, 'checkpoint_%d.pth.tar' % global_iter) # lr decay if global_iter % args.lr_decay == 0: args.lr = args.lr * 0.1 optimizer = adjust_learning_rate(optimizer, args.lr) print("Training is over...") save_checkpoint(model.state_dict(), log_folder, 'last_checkpoint.pth.tar')
if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--img_size', type=int, default=64) parser.add_argument('--ckpt', type=str, required=True) parser.add_argument('--dataset', type=str) parser.add_argument('--img_type', type=str, default='rgb') parser.add_argument('--device', type=str, default='cuda:1') args = parser.parse_args() device = args.device torch.cuda.set_device(device) # Initialise model model = util.load_model(args.img_type, device, args.ckpt, args.img_size) model.eval() if args.dataset == None: dataset = {'train', 'val'} else: dataset = {args.dataset} for ds in dataset: dataset_path = f'/shared/users/patriri/carla_data/{args.img_type}/rnn/{ds}/' dataset = datasets.DatasetFolder( root=dataset_path, loader=npy_loader, extensions='.npy', ) loader = DataLoader(dataset, batch_size=1, shuffle=False,
# 部首有663个 model = HDENet(663, 256, "resnet34") device = None if torch.cuda.is_available(): cudnn.benchmark = True device = 'cuda' else: device = "cpu" model.to(device) # resume if is_resume: util.load_model(model, resume_path) start_epoch = int(re.sub("\D", "", resume_path)) + 1 optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.9) scheduler = lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.9) for epoch in range(start_epoch, start_epoch + epochs): train_loss = [] test_loss = [] train_acc = [] test_acc = [] scheduler.step() model.train()
if __name__ == '__main__': args = parse_args() config = get_config() logger.info(config) CQIL_helper = CQILHelper(config) logger.info('Constructing Model...') model = CQIL(config) logger.info(model) if config['reload'] > 0: logger.info('load model') load_model(model, config['model_filepath']) model = model.to(torch.device(f"cuda:{config['gpu_id']}" if torch.cuda.is_available() else "cpu")) total_params = sum(p.numel() for p in model.parameters() if p.requires_grad) logger.info('total parameters: ' + str(total_params)) if args.mode == 'train': CQIL_helper.train(config, model) elif args.mode == 'valid': valid_dataset = TestDataset(config, dataset_type='valid') CQIL_helper.test(config, model, valid_dataset) elif args.mode == 'eval': eval_dataset = TestDataset(config, dataset_type='eval')
dataset_val = datasets.DatasetFolder( root=path_val, loader=npy_loader, extensions='.npy', ) loader_train = DataLoader(dataset_train, batch_size=args.batch, shuffle=True, num_workers=4) loader_val = DataLoader(dataset_val, batch_size=args.batch, shuffle=True, num_workers=4) if args.pred is True: model_vqvae = util.load_model(args.img_type, args.device, args.vqvae, args.img_size) model_vqvae.eval() path_test = f'/shared/users/patriri/carla_data/{args.img_type}/rnn/val' dataset_test = datasets.DatasetFolder( root=path_test, loader=npy_loader, extensions='.npy', ) loader_test = DataLoader(dataset_test, batch_size=1, shuffle=False, num_workers=4) predict(loader_test, model_rnn, model_vqvae, args) else: