def dataloader_factory(args): dataset = dataset_factory(args) dataloader = DATALOADERS[args.dataloader_code] dataloader = dataloader(args, dataset) meta = dataloader.get_meta() train, val, test = dataloader.get_pytorch_dataloaders() return meta, train, val, test
def test_with_dataset_factory(self): train_dataset = dataset_factory('none') idx = random.randint(a=0, b=len(train_dataset)) img, label = train_dataset[idx] self.assertEqual(2867, len(train_dataset)) self.assertTupleEqual((3, 513, 513), np.shape(img)) self.assertTupleEqual((513, 513), np.shape(label))
def main(): import argparse parser = argparse.ArgumentParser(description="Evaluate model on dataset") parser.add_argument("dataset", choices=["casia-b"]) parser.add_argument("weights_path") parser.add_argument("data_path") parser.add_argument("--network_name", default="resgcn-n39-r8") parser.add_argument("--sequence_length", type=int, default=60) parser.add_argument("--batch_size", type=int, default=256) parser.add_argument("--embedding_layer_size", type=int, default=128) parser.add_argument("--use_multi_branch", action="store_true") parser.add_argument("--shuffle", action="store_true") opt = parser.parse_args() # Config for dataset graph = Graph("coco") dataset_class = dataset_factory(opt.dataset) evaluation_fn = None if opt.dataset == "casia-b": evaluation_fn = _evaluate_casia_b # Load data dataset = dataset_class( opt.data_path, train=False, sequence_length=opt.sequence_length, transform=transforms.Compose([ SelectSequenceCenter(opt.sequence_length), ShuffleSequence(opt.shuffle), MultiInput(graph.connect_joint, opt.use_multi_branch), ToTensor() ]), ) data_loader = DataLoader(dataset, batch_size=opt.batch_size) print(f"Data loaded: {len(data_loader)} batches") # Init model model, model_args = get_model_resgcn(graph, opt) if torch.cuda.is_available(): model.cuda() # Load weights checkpoint = torch.load(opt.weights_path) model.load_state_dict(checkpoint["model"]) result, accuracy_avg, sub_accuracies, dataframe = evaluate(data_loader, model, evaluation_fn, use_flip=True) print("\n") print((dataframe * 100).round(2)) print(f"AVG: {accuracy_avg*100} %") print("=================================") print((dataframe * 100).round(1).to_latex()) print((dataframe * 100).round(1).to_markdown())
def test(args): model = BertForQuestionAnswering.from_pretrained(PRETRAINED_MODEL_NAME) model.load_state_dict( torch.load('{}/model/best_model.bin'.format(args.load_model_path))) test_set = dataset_factory(args, tokenizer) BertQA = BertQATrainer(args, model, None, None, test_set) BertQA.evaluate(tokenizer, _write=True) pass
def dataloader_factory(args): """ This method loads the specified dataset using the dataset factory and returns the three data loaders :param args: system wide arguments from options.py :return: train, validation, test data loaders """ dataset = dataset_factory(args) dataloader = DATALOADERS[args.dataloader_code] dataloader = dataloader(args, dataset) train, val, test = dataloader.get_pytorch_dataloaders() return train, val, test
def train(args): # Load BERT QA pre-trained model model = BertForQuestionAnswering.from_pretrained(PRETRAINED_MODEL_NAME) # high-level 顯示此模型裡的 modules displayBertModules(model) train_loader, val_loader = dataset_factory(args, tokenizer) BertQA = BertQATrainer(args, model, train_loader, val_loader, None) BertQA.train() pass
def test(args): test_loader = dataset_factory(args, tokenizer) # Load BERT QA pre-trained model model = BertForTokenClassification.from_pretrained( PRETRAINED_MODEL_NAME, return_dict=True, num_labels=args.tag_nums # 設定模型 output label nums ) model.load_state_dict( torch.load('{}/model/best_model.bin'.format(args.load_model_path))) # high-level 顯示此模型裡的 modules displayBertModules(model) BertTC = BertTCTrainer(args, model, None, None, test_loader) BertTC.evaluate(tokenizer) pass
def train(args): train_loader, val_loader = dataset_factory(args, tokenizer) print(len(train_loader), len(val_loader)) print(args) # Load BERT QA pre-trained model model = BertForTokenClassification.from_pretrained( PRETRAINED_MODEL_NAME, return_dict=True, num_labels=args.tag_nums # 設定模型 output label nums ) # high-level 顯示此模型裡的 modules displayBertModules(model) BertTC = BertTCTrainer(args, model, train_loader, val_loader, None) BertTC.train() pass
def main(args): export_root, args = setup_experiments(args) device = args.device model_checkpoint_path = os.path.join(export_root, 'models') train_dataset = dataset_factory(args.train_transform_type, is_train=True) val_dataset = dataset_factory(args.val_transform_type, is_train=False) dataloaders = dataloaders_factory(train_dataset, val_dataset, args.batch_size, args.test) model = model_factory(args) writer = SummaryWriter(os.path.join(export_root, 'logs')) train_loggers = [ MetricGraphPrinter(writer, key='loss', graph_name='loss', group_name='Train'), MetricGraphPrinter(writer, key='epoch', graph_name='Epoch', group_name='Train'), ] val_loggers = [ MetricGraphPrinter(writer, key='mean_iou', graph_name='mIOU', group_name='Validation'), MetricGraphPrinter(writer, key='acc', graph_name='Accuracy', group_name='Validation'), RecentModelLogger(model_checkpoint_path), BestModelLogger(model_checkpoint_path, metric_key='mean_iou'), ImagePrinter(writer, train_dataset, log_prefix='train'), ImagePrinter(writer, val_dataset, log_prefix='val') ] criterion = create_criterion(args) optimizer = create_optimizer(model, args) if args.pretrained_weights: load_pretrained_weights(args, model) if args.resume_training: setup_to_resume(args, model, optimizer) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.decay_step, gamma=args.gamma) trainer = Trainer(model, dataloaders, optimizer, criterion, args.epoch, args, num_classes=args.classes, log_period_as_iter=args.log_period_as_iter, train_loggers=train_loggers, val_loggers=val_loggers, lr_scheduler=scheduler, device=device) trainer.train() writer.close()
def main(opt): opt = setup_environment(opt) graph = Graph("coco") # Dataset transform = transforms.Compose([ MirrorPoses(opt.mirror_probability), FlipSequence(opt.flip_probability), RandomSelectSequence(opt.sequence_length), ShuffleSequence(opt.shuffle), PointNoise(std=opt.point_noise_std), JointNoise(std=opt.joint_noise_std), MultiInput(graph.connect_joint, opt.use_multi_branch), ToTensor() ], ) dataset_class = dataset_factory(opt.dataset) dataset = dataset_class( opt.train_data_path, train=True, sequence_length=opt.sequence_length, transform=TwoNoiseTransform(transform), ) dataset_valid = dataset_class( opt.valid_data_path, sequence_length=opt.sequence_length, transform=transforms.Compose([ SelectSequenceCenter(opt.sequence_length), MultiInput(graph.connect_joint, opt.use_multi_branch), ToTensor() ]), ) train_loader = torch.utils.data.DataLoader( dataset, batch_size=opt.batch_size, num_workers=opt.num_workers, pin_memory=True, shuffle=True, ) val_loader = torch.utils.data.DataLoader( dataset_valid, batch_size=opt.batch_size_validation, num_workers=opt.num_workers, pin_memory=True, ) # Model & criterion model, model_args = get_model_resgcn(graph, opt) criterion = SupConLoss(temperature=opt.temp) print("# parameters: ", count_parameters(model)) if torch.cuda.device_count() > 1: model = torch.nn.DataParallel(model, opt.gpus) if opt.cuda: model.cuda() criterion.cuda() # Trainer optimizer, scheduler, scaler = get_trainer(model, opt, len(train_loader)) # Load checkpoint or weights load_checkpoint(model, optimizer, scheduler, scaler, opt) # Tensorboard writer = SummaryWriter(log_dir=opt.tb_path) sample_input = torch.zeros(opt.batch_size, model_args["num_input"], model_args["num_channel"], opt.sequence_length, graph.num_node).cuda() writer.add_graph(model, input_to_model=sample_input) best_acc = 0 loss = 0 for epoch in range(opt.start_epoch, opt.epochs + 1): # train for one epoch time1 = time.time() loss = train(train_loader, model, criterion, optimizer, scheduler, scaler, epoch, opt) time2 = time.time() print(f"epoch {epoch}, total time {time2 - time1:.2f}") # tensorboard logger writer.add_scalar("loss/train", loss, epoch) writer.add_scalar("learning_rate", optimizer.param_groups[0]["lr"], epoch) # evaluation result, accuracy_avg, sub_accuracies, dataframe = evaluate( val_loader, model, opt.evaluation_fn, use_flip=True) writer.add_text("accuracy/validation", dataframe.to_markdown(), epoch) writer.add_scalar("accuracy/validation", accuracy_avg, epoch) for key, sub_accuracy in sub_accuracies.items(): writer.add_scalar(f"accuracy/validation/{key}", sub_accuracy, epoch) print(f"epoch {epoch}, avg accuracy {accuracy_avg:.4f}") is_best = accuracy_avg > best_acc if is_best: best_acc = accuracy_avg if opt.tune: tune.report(accuracy=accuracy_avg) if epoch % opt.save_interval == 0 or ( is_best and epoch > opt.save_best_start * opt.epochs): save_file = os.path.join( opt.save_folder, f"ckpt_epoch_{'best' if is_best else epoch}.pth") save_model(model, optimizer, scheduler, scaler, opt, opt.epochs, save_file) # save the last model save_file = os.path.join(opt.save_folder, "last.pth") save_model(model, optimizer, scheduler, scaler, opt, opt.epochs, save_file) log_hyperparameter(writer, opt, best_acc, loss) print(f"best accuracy: {best_acc*100:.2f}")
else: device = torch.device('cpu') # seed if opt.manualSeed is None: opt.manualSeed = random.randint(1, 10000) random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) if opt.device > -1: torch.cuda.manual_seed_all(opt.manualSeed) ####################################################################################################################### # Data ####################################################################################################################### # -- load data setup, (train_data, test_data), relations = dataset_factory(opt.datadir, opt.dataset, opt.nt_train,opt.khop) train_data = train_data.to(device) test_data = test_data.to(device) relations = relations.to(device) for k, v in setup.items(): opt[k] = v # -- train inputs t_idx = torch.arange(opt.nt_train, out=torch.LongTensor()).unsqueeze(1).expand(opt.nt_train, opt.nx).contiguous() x_idx = torch.arange(opt.nx, out=torch.LongTensor()).expand_as(t_idx).contiguous() # dynamic idx_dyn = torch.stack((t_idx[1:], x_idx[1:])).view(2, -1).to(device) nex_dyn = idx_dyn.size(1) # decoder idx_dec = torch.stack((t_idx, x_idx)).view(2, -1).to(device) nex_dec = idx_dec.size(1)
else: device = torch.device('cpu') # seed if opt.manualSeed is None: opt.manualSeed = random.randint(1, 10000) random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) if opt.device > -1: torch.cuda.manual_seed_all(opt.manualSeed) ####################################################################################################################### # Data ####################################################################################################################### # -- load data setup, (train_data, test_data), relations = dataset_factory(opt.datadir, opt.dataset, opt.khop) train_data = train_data.to(device) test_data = test_data.to(device) relations = relations.to(device) for k, v in setup.items(): opt[k] = v # -- train inputs t_idx = torch.arange(opt.nt_train, out=torch.LongTensor()).unsqueeze(1).expand( opt.nt_train, opt.nx).contiguous() x_idx = torch.arange(opt.nx, out=torch.LongTensor()).expand_as(t_idx).contiguous() # dynamic idx_dyn = torch.stack((t_idx[1:], x_idx[1:])).view(2, -1).to(device) nex_dyn = idx_dyn.size(1) # decoder
device = torch.device('cpu') # seed if opt.manualSeed is None: opt.manualSeed = random.randint(1, 10000) random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) if opt.device > -1: torch.cuda.manual_seed_all(opt.manualSeed) ####################################################################################################################### # Data ####################################################################################################################### # -- load data setup, (train_data, test_data), relations, (exogenous_train, exogenous_test) = dataset_factory( opt.datadir, opt.dataset, opt.khop) train_data = train_data.to(device) test_data = test_data.to(device) exogenous_train = exogenous_train.to(device) exogenous_test = exogenous_test.to(device) relations = relations.to(device) for k, v in setup.items(): opt[k] = v # -- train inputs t_idx = torch.arange(opt.nt_train, out=torch.LongTensor()).unsqueeze(1).expand( opt.nt_train, opt.nx).contiguous() x_idx = torch.arange(opt.nx, out=torch.LongTensor()).expand_as(t_idx).contiguous() # dynamic
def get_dataloader(args): dataset = dataset_factory(args) dataloader = DATALOADERS[args.dataloader_code] dataloader = dataloader(args, dataset) return dataloader