def main(args): exp_users = range(*args.exp_users) dev_users = range(*args.dev_users) assert len( set(exp_users).intersection(set(dev_users))) == 0, 'Exploitation set and Development set must not overlap' state_dict, class_weights, forg_weights = torch.load(args.model_path, map_location=lambda storage, loc: storage) device = torch.device('cuda', args.gpu_idx) if torch.cuda.is_available() else torch.device('cpu') print('Using device: {}'.format(device)) base_model = models.available_models[args.model]().to(device)#.eval() base_model.load_state_dict(state_dict) def process_fn(batch): input = batch[0].to(device) return base_model(input) x, y, yforg, user_mapping, filenames = load_dataset(args.data_path) features = extract_features(x, process_fn, args.batch_size, args.input_size) data = (features, y, yforg) exp_set = get_subset(data, exp_users) dev_set = get_subset(data, dev_users) rng = np.random.RandomState(1234) eer_u_list = [] eer_list = [] all_results = [] for _ in range(args.folds): classifiers, results = training.train_test_all_users(exp_set, dev_set, svm_type=args.svm_type, C=args.svm_c, gamma=args.svm_gamma, num_gen_train=args.gen_for_train, num_forg_from_exp=args.forg_from_exp, num_forg_from_dev=args.forg_from_dev, num_gen_test=args.gen_for_test, rng=rng) this_eer_u, this_eer = results['all_metrics']['EER_userthresholds'], results['all_metrics']['EER'] all_results.append(results) eer_u_list.append(this_eer_u) eer_list.append(this_eer) print('EER (global threshold): {:.2f} (+- {:.2f})'.format(np.mean(eer_list) * 100, np.std(eer_list) * 100)) print('EER (user thresholds): {:.2f} (+- {:.2f})'.format(np.mean(eer_u_list) * 100, np.std(eer_u_list) * 100)) if args.save_path is not None: print('Saving results to {}'.format(args.save_path)) with open(args.save_path, 'wb') as f: pickle.dump(all_results, f) return all_results
def main(args): # Setup logging logdir = pathlib.Path(args.logdir) if not logdir.exists(): logdir.mkdir() if args.visdomport is not None: logger = VisdomLogger(port=args.visdomport) else: logger = None device = torch.device('cuda', args.gpu_idx) if torch.cuda.is_available() else torch.device('cpu') print('Using device: {}'.format(device)) torch.manual_seed(args.seed) if torch.cuda.is_available(): torch.cuda.manual_seed_all(args.seed) print('Loading Data') x, y, yforg, usermapping, filenames = util.load_dataset(args.dataset_path) data = util.get_subset((x, y, yforg), subset=range(*args.users)) if not args.forg: data = util.remove_forgeries(data, forg_idx=2) train_loader, val_loader = setup_data_loaders(data, args.batch_size, args.input_size) print('Initializing Model') n_classes = len(np.unique(data[1])) base_model = models.available_models[args.model]().to(device) classification_layer = nn.Linear(base_model.feature_space_size, n_classes).to(device) if args.forg: forg_layer = nn.Linear(base_model.feature_space_size, 1).to(device) else: forg_layer = nn.Module() # Stub module with no parameters if args.test: print('Testing') base_model_params, classification_params, forg_params = torch.load(args.checkpoint) base_model.load_state_dict(base_model_params) classification_layer.load_state_dict(classification_params) if args.forg: forg_layer.load_state_dict(forg_params) val_acc, val_loss, val_forg_acc, val_forg_loss = test(val_loader, base_model, classification_layer, device, args.forg, forg_layer) if args.forg: print('Val loss: {:.4f}, Val acc: {:.2f}%,' 'Val forg loss: {:.4f}, Val forg acc: {:.2f}%'.format(val_loss, val_acc * 100, val_forg_loss, val_forg_acc * 100)) else: print('Val loss: {:.4f}, Val acc: {:.2f}%'.format(val_loss, val_acc * 100)) else: print('Training') train(base_model, classification_layer, forg_layer, train_loader, val_loader, device, logger, args, logdir)
from sigver.preprocessing.normalize import crop_center_multiple if __name__ == '__main__': parser = argparse.ArgumentParser(description='Run adversarial attacks') parser.add_argument('--dataset-path', required=True) parser.add_argument('--models-path', required=True, nargs='*') parser.add_argument('--save-path', required=True, nargs='*') parser.add_argument('--users', default=None, nargs=2, type=int) parser.add_argument('--seed', default=1234) args = parser.parse_args() rng = np.random.RandomState(args.seed) # Load and split the dataset x, y, yforg, user_mapping, filenames = load_dataset(args.dataset_path) assert len(args.models_path) == len( args.save_path), 'Inform one save file for each model' device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') batch_size = 32 input_size = (150, 220) x = crop_center_multiple( x, input_size ) # For the attacks, we will consider the inputs at size 150, 220 all_cnn_features = [] all_models = [] all_classifiers = [] all_thresholds_rbf = []
#!/usr/bin/env python3 import pickle import numpy as np import sys import sigver.datasets.util as util from PIL import Image if __name__ == "__main__": x, y, yforg, usermapping, filenames = util.load_dataset(sys.argv[1]) i = int(sys.argv[2]) imgData = x[i][0] img = Image.fromarray(imgData, 'L') img.show() print(imgData.shape) print(y[i]) print(yforg[i]) # for i in range(150): # for j in range(220): # bit = imgData[i][j] # if bit not in [0, 1]: # print(bit)
def main(args): rng = np.random.RandomState(args.seed) if args.test: assert args.checkpoint is not None, 'Please inform the checkpoint (trained model)' if args.logdir is None: logdir = get_logdir(args) else: logdir = pathlib.Path(args.logdir) if not logdir.exists(): logdir.mkdir() print('Writing logs to {}'.format(logdir)) device = torch.device( 'cuda', args.gpu_idx) if torch.cuda.is_available() else torch.device('cpu') if args.port is not None: logger = VisdomLogger(port=args.port) else: logger = None print('Loading Data') x, y, yforg, usermapping, filenames = load_dataset(args.dataset_path) dev_users = range(args.dev_users[0], args.dev_users[1]) if args.devset_size is not None: # Randomly select users from the dev set dev_users = rng.choice(dev_users, args.devset_size, replace=False) if args.devset_sk_size is not None: assert args.devset_sk_size <= len( dev_users), 'devset-sk-size should be smaller than devset-size' # Randomly select users from the dev set to have skilled forgeries (others don't) dev_sk_users = set( rng.choice(dev_users, args.devset_sk_size, replace=False)) else: dev_sk_users = set(dev_users) print('{} users in dev set; {} users with skilled forgeries'.format( len(dev_users), len(dev_sk_users))) if args.exp_users is not None: val_users = range(args.exp_users[0], args.exp_users[1]) print('Testing with users from {} to {}'.format( args.exp_users[0], args.exp_users[1])) elif args.use_testset: val_users = range(0, 300) print('Testing with Exploitation set') else: val_users = range(300, 350) print('Initializing model') base_model = models.available_models[args.model]().to(device) weights = base_model.build_weights(device) maml = MAML(base_model, args.num_updates, args.num_updates, args.train_lr, args.meta_lr, args.meta_min_lr, args.epochs, args.learn_task_lr, weights, device, logger, loss_function=balanced_binary_cross_entropy, is_classification=True) if args.checkpoint: params = torch.load(args.checkpoint) maml.load(params) if args.test: test_and_save(args, device, logdir, maml, val_users, x, y, yforg) return # Pretraining if args.pretrain_epochs > 0: print('Pre-training') data = util.get_subset((x, y, yforg), subset=range(350, 881)) wrapped_model = PretrainWrapper(base_model, weights) if not args.pretrain_forg: data = util.remove_forgeries(data, forg_idx=2) train_loader, val_loader = pretrain.setup_data_loaders( data, 32, args.input_size) n_classes = len(np.unique(y)) classification_layer = nn.Linear(base_model.feature_space_size, n_classes).to(device) if args.pretrain_forg: forg_layer = nn.Linear(base_model.feature_space_size, 1).to(device) else: forg_layer = nn.Module() # Stub module with no parameters pretrain_args = argparse.Namespace(lr=0.01, lr_decay=0.1, lr_decay_times=1, momentum=0.9, weight_decay=0.001, forg=args.pretrain_forg, lamb=args.pretrain_forg_lambda, epochs=args.pretrain_epochs) print(pretrain_args) pretrain.train(wrapped_model, classification_layer, forg_layer, train_loader, val_loader, device, logger, pretrain_args, logdir=None) # MAML training trainset = MAMLDataSet(data=(x, y, yforg), subset=dev_users, sk_subset=dev_sk_users, num_gen_train=args.num_gen, num_rf_train=args.num_rf, num_gen_test=args.num_gen_test, num_rf_test=args.num_rf_test, num_sk_test=args.num_sk_test, input_shape=args.input_size, test=False, rng=np.random.RandomState(args.seed)) val_set = MAMLDataSet(data=(x, y, yforg), subset=val_users, num_gen_train=args.num_gen, num_rf_train=args.num_rf, num_gen_test=args.num_gen_test, num_rf_test=args.num_rf_test, num_sk_test=args.num_sk_test, input_shape=args.input_size, test=True, rng=np.random.RandomState(args.seed)) loader = DataLoader(trainset, batch_size=args.meta_batch_size, shuffle=True, num_workers=2, collate_fn=trainset.collate_fn) print('Training') best_val_acc = 0 with tqdm(initial=0, total=len(loader) * args.epochs) as pbar: if args.checkpoint is not None: postupdate_accs, postupdate_losses, preupdate_losses = test_one_epoch( maml, val_set, device, args.num_updates) if logger: for i in range(args.num_updates): logger.scalar('val_postupdate_loss_{}'.format(i), 0, np.mean(postupdate_losses, axis=0)[i]) logger.scalar('val_postupdate_acc_{}'.format(i), 0, np.mean(postupdate_accs, axis=0)[i]) for epoch in range(args.epochs): loss_weights = get_per_step_loss_importance_vector( args.num_updates, args.msl_epochs, epoch) n_batches = len(loader) for step, item in enumerate(loader): item = move_to_gpu(*item, device=device) maml.meta_learning_step((item[0], item[1]), (item[2], item[3]), loss_weights, epoch + step / n_batches) pbar.update(1) maml.scheduler.step() postupdate_accs, postupdate_losses, preupdate_losses = test_one_epoch( maml, val_set, device, args.num_updates) if logger: for i in range(args.num_updates): logger.scalar('val_postupdate_loss_{}'.format(i), epoch + 1, np.mean(postupdate_losses, axis=0)[i]) logger.scalar('val_postupdate_acc_{}'.format(i), epoch + 1, np.mean(postupdate_accs, axis=0)[i]) logger.save(logdir / 'train_curves.pickle') this_val_loss = np.mean(postupdate_losses, axis=0)[-1] this_val_acc = np.mean(postupdate_accs, axis=0)[-1] if this_val_acc > best_val_acc: best_val_acc = this_val_acc torch.save(maml.parameters, logdir / 'best_model.pth') print('Epoch {}. Val loss: {:.4f}. Val Acc: {:.2f}%'.format( epoch, this_val_loss, this_val_acc * 100)) # Re-load best parameters and test with 10 folds params = torch.load(logdir / 'best_model.pth') maml.load(params) test_and_save(args, device, logdir, maml, val_users, x, y, yforg)
#canvas_size = (952, 1360) # Maximum signature size # If GPU is available, use it: device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print('Using device: {}'.format(device)) ## Load and pre-process the signature #original = img_as_ubyte(imread('data/some_signature.png', as_gray=True)) #processed = preprocess_signature(original, canvas_size) # ## Note: the image needs to be a pytorch tensor with pixels in the range [0, 1] #input = torch.from_numpy(processed).view(1, 1, 150, 220) #input = input.float().div(255).to(device) x, y, yforg, usermapping, filenames = util.load_dataset( "persian_1_115_150-220.npz") i = int(sys.argv[1]) j = int(sys.argv[2]) input1 = torch.from_numpy(x[i][0]).view(1, 1, 150, 220) input1 = input1.float().div(255).to(device) input2 = torch.from_numpy(x[j][0]).view(1, 1, 150, 220) input2 = input2.float().div(255).to(device) # Load the model #state_dict, _, _ = torch.load('pre_trained/signet_f_lambda_0.95.pth') state_dict, _, _ = torch.load('signet_with_forgery_150-220/model_best.pth') base_model = SigNet().to(device).eval() base_model.load_state_dict(state_dict) # Extract features with torch.no_grad(
import argparse import os from skimage.io import imsave from sigver.datasets.util import load_dataset from tqdm import tqdm parser = argparse.ArgumentParser() parser.add_argument('--data-path', required=True) parser.add_argument('--save-path', required=True) args = parser.parse_args() data = load_dataset(args.data_path) if not os.path.exists(args.save_path): os.mkdir(args.save_path) x, _, _, _, filenames = data for img, filename in tqdm(zip(x, filenames), total=len(x)): full_name = os.path.join(args.save_path, filename) imsave(full_name, 255 - img.squeeze())