def main(): parser = argparse.ArgumentParser() parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=64) parser.add_argument('--epoches', type=int, default=50) parser.add_argument('--GPU_COUNT', type=int, default=2) parser.add_argument('--show_status', type=bool, default=True) config = parser.parse_args() trainer = Train(config) trainer.train()
def start_train(train_iter, dev_iter, test_iter, model, config): """ :param train_iter: train batch data iterator :param dev_iter: dev batch data iterator :param test_iter: test batch data iterator :param model: nn model :param config: config :return: None """ t = Train(train_iter=train_iter, dev_iter=dev_iter, test_iter=test_iter, model=model, config=config) t.train() print("Finish Train.")
def __init__(self, **kwargs): self.__name__ = kwargs.get('name', 'NSITBot') self.__owner__ = kwargs.get('owner', 'NSIT 2020') self.__version__ = kwargs.get('version', 'Test') """ creating an instance of trainer inside NSITBot """ self.trainer = Train(name='TrainerBot') self.hello_bot = [ 'bot_action', 'bot_author', 'bot_name', 'bot_version', 'hello', 'endings' ] """ fetching the classifier and vectorizer that the NSITBot will use to predict the classes of the recieved messaged from the user end. """ self.classifier, self.vectorizer = self.trainer.getClassifier()
def main(config): """Main entry point of train module.""" # Initialize the dataset # Full dataset # dataset = ICDARDataset('/content/ch4_training_images', '/content/ch4_training_localization_transcription_gt') data_df = pd.read_csv(f"{config['data_base_dir']}/train.csv") dataset = Synth800kPreprocessedDataset(config["data_base_dir"], data_df) # Train test split val_size = config["val_fraction"] val_len = int(val_size * len(dataset)) train_len = len(dataset) - val_len icdar_train_dataset, icdar_val_dataset = torch.utils.data.random_split( dataset, [train_len, val_len]) icdar_train_data_loader = DataLoader(icdar_train_dataset, pin_memory=True, **config["dataset_config"], worker_init_fn=seed_worker # collate_fn=icdar_collate ) icdar_val_data_loader = DataLoader(icdar_val_dataset, **config["dataset_config"], pin_memory=True, worker_init_fn=seed_worker # collate_fn=icdar_collate ) # Initialize the model model = FOTSModel() # Count trainable parameters print(f'The model has {count_parameters(model):,} trainable parameters.') loss = FOTSLoss(config) optimizer = model.get_optimizer(config["optimizer"], config["optimizer_config"]) lr_schedular = getattr(optim.lr_scheduler, config["lr_schedular"], "ReduceLROnPlateau")( optimizer, **config["lr_scheduler_config"]) trainer = Train(model, icdar_train_data_loader, icdar_val_data_loader, loss, fots_metric, optimizer, lr_schedular, config) trainer.train()
def get_trainer(self): if self._trainer is None: self._trainer = Train( model_dir=self.model_dir, label_mapper=self.get_label_mapper(), epochs=self.epochs, early_stopping_patience=self.early_stopping_patience, checkpoint_frequency=self.checkpoint_frequency, checkpoint_dir=self.checkpoint_dir, accumulation_steps=self.grad_accumulation_steps) return self._trainer
def main(): """ Descrition : main module to run code """ parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=24) parser.add_argument('--epochs', type=int, default=150) parser.add_argument('--N', type=int, default=10) parser.add_argument('--K', type=int, default=5) parser.add_argument('--iterations', type=int, default=1000) parser.add_argument('--input_dims', type=int, default=64) parser.add_argument('--download', type=bool, default=False) parser.add_argument('--GPU_COUNT', type=int, default=1) parser.add_argument('--logdir', type=str, default='./log') parser.add_argument('--modeldir', type=str, default='./models') config = parser.parse_args() # create output dir try: os.makedirs(config.logdir) os.makedirs(config.modeldir) except OSError: pass trainer = Train(config) trainer.train() if config.generation: trainer.generation()
def main(): """ Description : run lipnet training code using argument info """ parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=64) parser.add_argument('--epochs', type=int, default=100) parser.add_argument('--image_path', type=str, default='./data/datasets/') parser.add_argument('--align_path', type=str, default='./data/align/') parser.add_argument('--dr_rate', type=float, default=0.5) parser.add_argument('--num_gpus', type=int, default=1) parser.add_argument('--num_workers', type=int, default=0) parser.add_argument('--model_path', type=str, default=None) config = parser.parse_args() trainer = Train(config) trainer.build_model(dr_rate=config.dr_rate, path=config.model_path) trainer.load_dataloader() trainer.run(epochs=config.epochs)
def main(): """ Description : run lipnet training code using argument info """ parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=64) parser.add_argument('--epochs', type=int, default=100) parser.add_argument('--image_path', type=str, default='./data/datasets/') parser.add_argument('--align_path', type=str, default='./data/align/') parser.add_argument('--dr_rate', type=float, default=0.5) parser.add_argument('--num_gpus', type=int, default=1) parser.add_argument('--num_workers', type=int, default=0) parser.add_argument('--model_path', type=str, default=None) config = parser.parse_args() trainer = Train(config) trainer.build_model(dr_rate=config.dr_rate, path=config.model_path) trainer.load_dataloader() trainer.run(epochs=config.epochs)
def main(): """ Description : run lipnet training code using argument info """ parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=64) parser.add_argument('--image_path', type=str, default='./data/datasets/') parser.add_argument('--align_path', type=str, default='./data/align/') parser.add_argument('--num_gpus', type=int, default=1) parser.add_argument('--num_workers', type=int, default=0) parser.add_argument('--data_type', type=str, default='valid') parser.add_argument('--model_path', type=str, default=None) config = parser.parse_args() trainer = Train(config) trainer.build_model(path=config.model_path) trainer.load_dataloader() if config.data_type == 'train': data_loader = trainer.train_dataloader elif config.data_type == 'valid': data_loader = trainer.valid_dataloader trainer.infer_batch(data_loader)
def main(): """ Description : run lipnet training code using argument info """ parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=64) parser.add_argument('--image_path', type=str, default='./data/datasets/') parser.add_argument('--align_path', type=str, default='./data/align/') parser.add_argument('--num_gpus', type=int, default=1) parser.add_argument('--num_workers', type=int, default=0) parser.add_argument('--data_type', type=str, default='valid') parser.add_argument('--model_path', type=str, default=None) config = parser.parse_args() trainer = Train(config) trainer.build_model(path=config.model_path) trainer.load_dataloader() if config.data_type == 'train': data_loader = trainer.train_dataloader elif config.data_type == 'valid': data_loader = trainer.valid_dataloader trainer.infer_batch(data_loader)
def main(): parser = argparse.ArgumentParser() parser = argparse.ArgumentParser() parser.add_argument('--batch_size', type=int, default=64) parser.add_argument('--epoches', type=int, default=10) parser.add_argument('--mu', type=int, default=128) parser.add_argument('--n_residue', type=int, default=24) parser.add_argument('--n_skip', type=int, default=128) parser.add_argument('--dilation_depth', type=int, default=10) parser.add_argument('--n_repeat', type=int, default=2) parser.add_argument('--seq_size', type=int, default=20000) parser.add_argument('--use_gpu', type=bool, default=False) parser.add_argument('--generation', type=bool, default=True) config = parser.parse_args() trainer = Train(config) trainer.train() if (config.generation): trainer.generation()
], 'weight_decay': 0.0 }] optimizer = AdamW(optimizer_grouped_parameters, lr=2e-5, eps=1e-8) # scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=len(train_loader)) crit = torch.nn.CrossEntropyLoss() trainer = Train(model_name='pure-bert', train_loader=train_loader, val_loader=val_loader, test_loader=test_loader, model=model, optimizer=optimizer, loss_fn=crit, epochs=10, print_step=10, early_stop_patience=3, save_model_path='/sdd/yujunshuai/save_model/pure_bert', save_model_every_epoch=True, metric=accuracy_score, num_class=2, tensorboard_path='/sdd/yujunshuai/tensorboard_log') trainer.train() print(f"Testing result :{trainer.test()}") # pure bert # Testing result :{'accuracy': 0.880089848977251, 'recall': 0.8658997206940136, 'f1': 0.8698654132943923}
'params': [ p for n, p in model.named_parameters() if any(nd in n for nd in no_decay) ], 'weight_decay': 0.0 }] optimizer = AdamW(optimizer_grouped_parameters, lr=args.lr, eps=1e-8) trainer = Train( model_name=args.model_name, train_loader=train_loader, test_loader=test_loader, device=args.device, model=model, optimizer=optimizer, epochs=12, print_step=1, early_stop_patience=3, save_model_path=f"./experiments/save_model/{args.model_name}", save_model_every_epoch=False, metric=accuracy_score, num_class=2, tensorboard_path=f'./experiments/tensorboard_log/{args.model_name}') # model_cache='./experiments/save_model/mr-gcn-layer-3/best-validate-model.pt') # print(trainer.eval()) print(trainer.train()) # print(trainer.test('./data/test.csv', './data/test_res.csv')) # print(trainer.test(test_loader, './data/test_new.csv', './data/test_new_res.csv'))
if any(nd in n for nd in no_decay) ], 'weight_decay': 0.0 }] optimizer = AdamW(optimizer_grouped_parameters, lr=args.lr, eps=1e-8) trainer = Train( model_name=args.model_name, train_loader=train_loader, test_loader=test_loader, device=args.device, model=model, optimizer=optimizer, epochs=args.epochs, print_step=1, early_stop_patience=args.early_stop_patience, save_model_path=f"./experiments/save_model/{args.model_name}", save_model_every_epoch=False, metric=accuracy_score, num_class=2, tensorboard_path=f'./experiments/tensorboard_log/{args.model_name}') if args.test and args.best_model_path: print( trainer.test(test_loader, './data/processed_modified_test_data.json', './data/processed_modified_test_data_result.json', args.best_model_path)) else:
no_decay = ['bias', 'LayerNorm.weight'] optimizer_grouped_parameters = [ {'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, {'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0} ] optimizer = AdamW(optimizer_grouped_parameters, lr=2e-5, eps=1e-8) crit = torch.nn.CrossEntropyLoss() trainer = Train(model_name=model_name, train_loader=train_loader, val_loader=val_loader, test_loader=test_loader, model=model, optimizer=optimizer, loss_fn=crit, epochs=12, print_step=1, early_stop_patience=3, # save_model_path=f"./save_model/{params['model_name']}", save_model_path=f"/sdd/yujunshuai/save_model/{model_name}", save_model_every_epoch=False, metric=accuracy_score, num_class=2, # tensorboard_path='./tensorboard_log') tensorboard_path='/sdd/yujunshuai/tensorboard_log') print(trainer.train()) print(trainer.test())
def main(config): cudnn.benchmark = True torch.manual_seed(1593665876) torch.cuda.manual_seed_all(4099049913103886) transform = transforms.Compose([ transforms.Resize((config.input_height, config.input_width)), transforms.ToTensor(), ]) ThreeD_dataloader = None kitti_dataloader = None if config.ThreeD == True: ThreeD_loader = ThreeD60.get_datasets(config.train_path, \ datasets=["suncg","m3d", "s2d3d"], placements=[ThreeD60.Placements.CENTER,ThreeD60.Placements.RIGHT,ThreeD60.Placements.UP], image_types=[ThreeD60.ImageTypes.COLOR, ThreeD60.ImageTypes.DEPTH, ThreeD60.ImageTypes.NORMAL], longitudinal_rotation=True) ThreeD_dataloader = DataLoader(ThreeD_loader, batch_size=config.batch_size, shuffle=True, num_workers=config.num_workers) if config.KITTI == True: kitti_loader = KITTI_loader(config.kitti_train_path, transform) kitti_dataloader = DataLoader(kitti_loader, batch_size=config.batch_size, shuffle=True, num_workers=config.num_workers) if config.mode == 'train': train = Train(config, ThreeD_dataloader, kitti_dataloader) train.train() elif config.mode == 'sample': train = Train(config, ThreeD_dataloader, kitti_dataloader) eval_name = 'evaluation' train.evaluate(config.val_path, config.checkpoint_path, eval_name) elif config.mode == 'make': train = Train(config, ThreeD_dataloader, kitti_dataloader) train.make_checkpoints()
def start_train(train_iter, test_iter, model, config): T = Train(train_iter=train_iter, test_iter=test_iter, model=model, config=config) T.train()
'params': [ p for n, p in model.named_parameters() if any(nd in n for nd in no_decay) ], 'weight_decay': 0.0 }] optimizer = AdamW(optimizer_grouped_parameters, lr=2e-5, eps=1e-8) crit = torch.nn.CrossEntropyLoss() trainer = Train( model_name=model_name, train_loader=train_loader, val_loader=val_loader, test_loader=test_loader, model=model, optimizer=optimizer, loss_fn=crit, epochs=10, print_step=10, early_stop_patience=3, save_model_path=f'/sdd/yujunshuai/save_model/{model_name}', save_model_every_epoch=False, metric=accuracy_score, num_class=2, tensorboard_path='/sdd/yujunshuai/tensorboard_log/fakeddit/') print(trainer.train()) print(f"Testing result :{trainer.test()}")
'weight_decay': 0.0 }, { 'params': [ p for n, p in model.named_parameters() if any(nd in n for nd in no_decay) ], 'weight_decay': 0.0 }] optimizer = AdamW(optimizer_grouped_parameters, lr=args.lr, eps=1e-8) crit = torch.nn.CrossEntropyLoss() trainer = Train(model_name=args.model_name, train_loader=train_loader, val_loader=test_loader, test_loader=None, model=model, optimizer=optimizer, epochs=args.epochs, print_step=args.log_interval, early_stop_patience=args.early_stop_patience, save_model_path=args.save_dir, save_model_every_epoch=False, metric=accuracy_score, num_class=args.output_size, tensorboard_path=args.save_dir, device=args.device) print(trainer.train())
def main(): nltk.download('wordnet') nltk.download('stopwords') tp = TextPreproc(WordNetLemmatizer(), stopwords.words('english')) dataset = Dataset(tp) train_X, train_Y = dataset.readdataTrain('data/train/*.txt') test_X = dataset.readdataTest('data/test.txt') classifier = LinearSVC(dual=False) params = {'C': [10**p for p in range(-2, 5)]} if charCount: ngram = 3 vectorizer = CharCountVectorizer(train_X, ngram) trainer = Train(classifier, params, -1, vectorizer) trainer.train(train_X, train_Y) trainer.predict(test_X, f'data/prediction/ngrams/ngrams_{ngram}') if tfidf: vectorizer = TfIdf(train_X) trainer = Train(classifier, params, -1, vectorizer) trainer.train(train_X, train_Y) trainer.predict(test_X, 'data/prediction/tfidf/tfidf') if word2: size = 300 vectorizer = Word2Vec(train_X, size=size, window=3, workers=4) trainer = Train(classifier, params, -1, vectorizer) trainer.train(train_X, train_Y) trainer.predict(test_X, 'data/prediction/word2vec/word2vec')