def main(): ############################################################## # Settings parser = argparse.ArgumentParser(description='Model AFN') parser.add_argument('--train-dir', help='train feature dir') parser.add_argument('--train-utt2label', help='train utt2label') parser.add_argument('--eval-dir', help='eval feature dir') parser.add_argument('--eval-utt2label', help='eval utt2label') parser.add_argument('--model-path', help='path to the pretrained model') parser.add_argument('--test-batch-size', type=int, default=100, metavar='N', help='input batch size for testing (default: 100)') parser.add_argument('--logging-dir', required=True, help='model save directory') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--seg', default=None, help='seg method') parser.add_argument('--seg-win', type=int, help='segmented window size') parser.add_argument('--quant-method', required=True, help='quantization method: dynamic static') args = parser.parse_args() torch.cuda.empty_cache() # Init model & Setup logs if args.seg is None: model = AttenResNet4(atten_activation, atten_channel, size1=(257, M), static_quant=True) run_name = "quant_pred-AFN4-1091-orig" + time.strftime("-%Y_%m_%d") else: if args.seg_win not in (64, 128, 256, 512): raise ValueError("Invalid segment window! Must be 64, 128, 256, or 512") model = AttenResNet4DeformAll(atten_activation, atten_channel, size1=(257, args.seg_win)) # noqa run_name = "quant_pred-AFN4De-" + str(args.seg_win) + "-" + args.seg + time.strftime("-%Y_%m_%d") # noqa logger = setup_logs(args.logging_dir, run_name) logger.info("use_cuda is False. Only runnable on CPU!") # Setting random seeds for reproducibility. np.random.seed(args.seed) random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True # CUDA determinism device = torch.device('cpu') model.to(device) ############################################################## # Loading the dataset & the best model params = {} logger.info('===> loading eval dataset: ' + args.eval_utt2label) train_set = SpoofDataset(args.train_dir, args.train_utt2label) train_loader = data.DataLoader( train_set, batch_size=BATCH_SIZE, shuffle=True, **params ) # set shuffle to True eval_set = SpoofDataset(args.eval_dir, args.eval_utt2label) eval_loader = data.DataLoader( eval_set, batch_size=TEST_BATCH_SIZE, shuffle=False, **params ) # set shuffle to False logger.info('===> loading best model for prediction: ' + args.model_path) checkpoint = torch.load( os.path.join(args.model_path), map_location=device ) model.load_state_dict(checkpoint['state_dict']) ############################################################## # apply network quantization & prediction model = apply_net_quant( model=model, logger=logger, quant_method=args.quant_method, calibration_loader=train_loader ) t_start_eval = timer() eval_loss, eval_eer = prediction(args, model, device, eval_loader, args.eval_utt2label, rnn) # noqa t_end_eval = timer() logger.info("#### Total prediction time: {}".format(t_end_eval - t_start_eval)) ########################################################### logger.info("################## Success #########################\n\n")
def main(): ############################################################## # Settings parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--train-scp', required=True, help='kaldi train scp file') parser.add_argument('--train-utt2label', required=True, help='train utt2label') parser.add_argument('--validation-scp', required=True, help='kaldi dev scp file') parser.add_argument('--validation-utt2label', required=True, help='dev utt2label') parser.add_argument('--eval-scp', help='kaldi eval scp file') parser.add_argument('--eval-utt2label', help='eval utt2label') parser.add_argument('--logging-dir', required=True, help='model save directory') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.001, metavar='LR', help='learning rate (default: 0.001)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging ' 'training status') parser.add_argument('--hidden-dim', type=int, default=100, help='number of neurones in the hidden dimension') parser.add_argument('--plot-wd', help='training plot directory') args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() print('use_cuda is', use_cuda) # print('temperature is', temperature) # Global timer global_timer = timer() # Setup logs logger = setup_logs(args.logging_dir, run_name) # Setting random seeds for reproducibility. np.random.seed(args.seed) random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) torch.backends.cudnn.deterministic = True # CUDA determinism device = torch.device("cuda:0" if use_cuda else "cpu") model.to(device) ############################################################## # Loading the dataset params = { 'num_workers': 16, 'pin_memory': True, 'worker_init_fn': np.random.seed(args.seed) } if use_cuda else {} logger.info('===> loading train and dev dataset') training_set = SpoofDataset(args.train_scp, args.train_utt2label) validation_set = SpoofDataset(args.validation_scp, args.validation_utt2label) train_loader = data.DataLoader(training_set, batch_size=batch_size, shuffle=True, **params) # set shuffle to True validation_loader = data.DataLoader(validation_set, batch_size=test_batch_size, shuffle=False, **params) # set shuffle to False logger.info('===> loading eval dataset') eval_set = SpoofDataset(args.eval_scp, args.eval_utt2label) eval_loader = data.DataLoader(eval_set, batch_size=test_batch_size, shuffle=False, **params) # set shuffle to False optimizer = optim.Adam(model.parameters(), lr=args.lr, amsgrad=True) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', factor=0.5, patience=1) model_params = sum(p.numel() for p in model.parameters() if p.requires_grad) logger.info('### Model summary below###\n {}\n'.format(str(model))) logger.info('===> Model total parameter: {}\n'.format(model_params)) ########################################################### # Start training best_eer, best_loss = np.inf, np.inf early_stopping, max_patience = 0, 5 # early stopping and maximum patience print(run_name) for epoch in range(1, args.epochs + 1): epoch_timer = timer() # Train and validate train(args, model, device, train_loader, optimizer, epoch, rnn) # train(args, model, device, train_loader, optimizer, epoch, # args.train_scp, args.train_utt2label, args.plot_wd, rnn=False) val_loss, eer = validation(args, model, device, validation_loader, args.validation_scp, args.validation_utt2label, rnn) scheduler.step(val_loss) # Save if select_best == 'eer': is_best = eer < best_eer best_eer = min(eer, best_eer) elif select_best == 'val': is_best = val_loss < best_loss best_loss = min(val_loss, best_loss) snapshot( args.logging_dir, run_name, is_best, { 'epoch': epoch + 1, 'best_eer': best_eer, 'state_dict': model.state_dict(), 'validation_loss': val_loss, 'optimizer': optimizer.state_dict(), }) # Early stopping if is_best == 1: early_stopping = 0 else: early_stopping += 1 end_epoch_timer = timer() logger.info("#### End epoch {}/{}, " "elapsed time: {}".format(epoch, args.epochs, end_epoch_timer - epoch_timer)) if early_stopping == max_patience: break ########################################################### # Prediction logger.info('===> loading best model for prediction') checkpoint = torch.load( os.path.join(args.logging_dir, run_name + '-model_best.pth')) model.load_state_dict(checkpoint['state_dict']) eval_loss, eval_eer = prediction(args, model, device, eval_loader, args.eval_scp, args.eval_utt2label, rnn) ########################################################### end_global_timer = timer() logger.info("################## Success #########################") logger.info("Total elapsed time: %s" % (end_global_timer - global_timer))
def main(): ############################################################## # Settings parser = argparse.ArgumentParser(description='Model AFN') parser.add_argument('--eval-dir', help='eval feature dir') parser.add_argument('--eval-utt2label', help='train utt2label') parser.add_argument('--model-path', help='path to the pretrained model') parser.add_argument('--test-batch-size', type=int, default=100, metavar='N', help='input batch size for testing (default: 100)') parser.add_argument('--logging-dir', required=True, help='model save directory') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--seg', default=None, help='seg method') parser.add_argument('--seg-win', type=int, help='segmented window size') parser.add_argument('--decomp-rank', type=int, help='rank value for decomposition') parser.add_argument('--decomp-type', default='tucker', help='decomposition type') args = parser.parse_args() torch.cuda.empty_cache() # Init model & Setup logs if args.seg is None: model = AttenResNet4(atten_activation, atten_channel, size1=(257, M)) run_name = "decomp_pred-AFN4-1091-orig" + time.strftime("-%Y_%m_%d") else: if args.seg_win not in (64, 128, 256, 512): raise ValueError("Invalid segment window! Must be 64, 128, 256, or 512") model = AttenResNet4DeformAll(atten_activation, atten_channel, size1=(257, args.seg_win)) # noqa run_name = "decomp_pred-AFN4De-" + str(args.seg_win) + "-" + args.seg + time.strftime("-%Y_%m_%d") # noqa logger = setup_logs(args.logging_dir, run_name) use_cuda = not args.no_cuda and torch.cuda.is_available() logger.info("use_cuda is {}".format(use_cuda)) # Setting random seeds for reproducibility. np.random.seed(args.seed) random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True # CUDA determinism device = torch.device("cuda" if use_cuda else "cpu") model.to(device) ############################################################## # Loading the dataset params = {'num_workers': 0, 'pin_memory': False, 'worker_init_fn': np.random.seed(args.seed)} if use_cuda else {} logger.info('===> loading eval dataset: ' + args.eval_utt2label) eval_set = SpoofDataset(args.eval_dir, args.eval_utt2label) eval_loader = data.DataLoader( eval_set, batch_size=TEST_BATCH_SIZE, shuffle=False, **params ) # set shuffle to False ############################################################## # apply network decomposition and load fine-tuned weights model.to('cpu') model = apply_net_decomp( model=model, logger=logger, rank=args.decomp_rank, decomp_type=args.decomp_type ) logger.info('===> loading fine-tuned model for prediction: ' + args.model_path) checkpoint = torch.load( os.path.join(args.model_path), map_location=device ) model.load_state_dict(checkpoint['state_dict']) model.to(device) t_start_eval = timer() eval_loss, eval_eer = prediction(args, model, device, eval_loader, args.eval_utt2label, rnn) # noqa t_end_eval = timer() logger.info("#### Total prediction time: {}".format(t_end_eval - t_start_eval)) ########################################################### logger.info("################## Success #########################\n\n")
def main(): ############################################################## # Settings parser = argparse.ArgumentParser(description='Model AFN') parser.add_argument('--train-dir', required=True, help='train feature dir') parser.add_argument('--train-utt2label', required=True, help='train utt2label') parser.add_argument('--validation-dir', required=True, help='dev feature dir') parser.add_argument('--validation-utt2label', required=True, help='dev utt2label') parser.add_argument('--eval-dir', help='eval feature dir') parser.add_argument('--eval-utt2label', help='train utt2label') parser.add_argument('--logging-dir', required=True, help='model save directory') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.001, metavar='LR', help='learning rate (default: 0.001)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument( '--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--seg', default=None, help='seg method') parser.add_argument('--seg-win', type=int, help='segmented window size') args = parser.parse_args() torch.cuda.empty_cache() # Init model & Setup logs if args.seg is None: model = AttenResNet4(atten_activation, atten_channel, size1=(257, M)) run_name = "AFN4" + time.strftime("-%Y_%m_%d-%H_%M_%S-") + str( M) + "-orig" else: model = AttenResNet4DeformAll(atten_activation, atten_channel, size1=(257, args.seg_win)) # noqa run_name = "AFN4De" + time.strftime("-%Y_%m_%d-%H_%M_%S-") + str( args.seg_win) + "-" + args.seg # noqa logger = setup_logs(args.logging_dir, run_name) use_cuda = not args.no_cuda and torch.cuda.is_available() logger.info("use_cuda is {}".format(use_cuda)) # Global timer global_timer = timer() # Setting random seeds for reproducibility. np.random.seed(args.seed) random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True # CUDA determinism device = torch.device("cuda" if use_cuda else "cpu") model.to(device) ############################################################## # Loading the dataset params = { 'num_workers': 0, 'pin_memory': False, 'worker_init_fn': np.random.seed(args.seed) } if use_cuda else {} logger.info('===> loading train and dev dataset') training_set = SpoofDataset(args.train_dir, args.train_utt2label) validation_set = SpoofDataset(args.validation_dir, args.validation_utt2label) train_loader = data.DataLoader(training_set, batch_size=BATCH_SIZE, shuffle=True, **params) # set shuffle to True validation_loader = data.DataLoader(validation_set, batch_size=TEST_BATCH_SIZE, shuffle=False, **params) # set shuffle to False optimizer = optim.Adam(model.parameters(), lr=args.lr, amsgrad=True) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', factor=0.5, patience=1) # noqa model_params = sum(p.numel() for p in model.parameters() if p.requires_grad) logger.info('#### Model summary below ####\n {}\n'.format(str(model))) logger.info('===> Model total # parameter: {}\n'.format(model_params)) ########################################################### # Training best_eer, best_loss = np.inf, np.inf early_stopping, max_patience = 0, 5 # early stopping and maximum patience total_train_time = [] for epoch in range(1, args.epochs + 1): epoch_timer = timer() # Train and validate train(args, model, device, train_loader, optimizer, epoch, rnn) val_loss, eer = validation(args, model, device, validation_loader, args.validation_utt2label, rnn) scheduler.step(val_loss) # Save if SELECT_BEST == 'eer': is_best = eer < best_eer best_eer = min(eer, best_eer) elif SELECT_BEST == 'val': is_best = val_loss < best_loss best_loss = min(val_loss, best_loss) snapshot( args.logging_dir, run_name, is_best, { 'epoch': epoch + 1, 'best_eer': best_eer, 'state_dict': model.state_dict(), 'validation_loss': val_loss, 'optimizer': optimizer.state_dict(), }) # Early stopping if is_best == 1: early_stopping = 0 else: early_stopping += 1 end_epoch_timer = timer() logger.info("#### End epoch {}/{}, elapsed time: {}".format( epoch, args.epochs, end_epoch_timer - epoch_timer)) # noqa total_train_time.append(end_epoch_timer - epoch_timer) if early_stopping == max_patience: break logger.info("#### Avg. training+validation time per epoch: {}".format( np.average(total_train_time))) # noqa ########################################################### # Prediction if args.eval_dir and args.eval_utt2label: logger.info('===> loading eval dataset') eval_set = SpoofDataset(args.eval_dir, args.eval_utt2label) eval_loader = data.DataLoader(eval_set, batch_size=TEST_BATCH_SIZE, shuffle=False, **params) # set shuffle to False logger.info('===> loading best model for prediction') checkpoint = torch.load( os.path.join(args.logging_dir, run_name + '-model_best.pth')) model.load_state_dict(checkpoint['state_dict']) t_start_eval = timer() eval_loss, eval_eer = prediction(args, model, device, eval_loader, args.eval_utt2label, rnn) # noqa end_global_timer = timer() logger.info( "#### Total prediction time: {}".format(end_global_timer - t_start_eval)) # noqa ########################################################### logger.info("################## Success #########################") logger.info("Total elapsed time: %s" % (end_global_timer - global_timer))