argparser.add_argument('--reduce_dim', default=False, type=ast.literal_eval) argparser.add_argument('--lr', default=1e-4, type=float) argparser.add_argument('--smoothing_epsilon', default=0.1, type=float) argparser.add_argument('--save_path', default='convnet/', type=str) argparser.add_argument('--plot_attention', default=False, type=ast.literal_eval) argparser.add_argument('--eval_step', default=10, type=int) argparser.add_argument('--max_epochs', default=500, type=int) argparser.add_argument('--train_acc_step', default=5, type=int) argparser.add_argument('--load_model', default=False, type=ast.literal_eval) argparser.add_argument('--clip_grad', default=False, type=ast.literal_eval) argparser.add_argument('--weight_decay', default=0., type=float) # L2 regularization -> 0.01 argparser.add_argument('--l1_reg', default=0., type=float) # L1 regularization -> 0.001 argparser.add_argument('--warmup', default=100, type=int) argparser.add_argument('--clip_grad_val', default=0.1, type=float) argparser.add_argument('--logfile', default='_convnet_experiments_feedback_logs.txt', type=str) args = argparser.parse_args() # logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.basicConfig(filename=args.logfile, filemode='a', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') settings = u.populate_configuration(settings, vars(args)) global plotter plotter = u.VisdomPlotter(env_name='ConvNet Experiments') if not os.path.isdir(settings['save_path']): os.makedirs(settings['save_path']) launch_experiment(settings)
parser.add_argument('-plot', action="store_true", default=False, help='Enable plotting') parser.add_argument('-trainTestBS', type=int, help='Ratio of Train BS to test BS') args = parser.parse_args() device = torch.device('cuda') # torch.manual_seed(0) # torch.cuda.manual_seed(0) # torch.backends.cudnn.deterministic = True # torch.backends.cudnn.benchmark = False # np.random.seed(0) torch.backends.cudnn.benchmark = True plotter = None if args.plot == True: plotter = utils.VisdomPlotter(env_name=args.name, modality='hallucinating') plotter.argsTile(args.__dict__) # Ready the training and validation data dataset = dataDef.twoStreamDataset(args.modality1, args.modality2) trainSampler, validationSampler = dataDef.testTrainSplit(len(dataset), args.valRatio) trainLoader = torch.utils.data.DataLoader(dataset, sampler=trainSampler, batch_size=args.batchSize, num_workers=8) valLoader = torch.utils.data.DataLoader(dataset, sampler=validationSampler, batch_size=args.trainTestBS*args.batchSize, num_workers=8) # Initialize our network if args.modality1 == 'PAN': net1 = modelDef.panNet() net2 = modelDef.msNet() model = modelDef.halucinationNet(net1, net2) testModel = modelDef.panNet() elif args.modality1 == 'MS':
#Data transform data_transform = transforms.Compose([ transforms.Resize((config.hyperparameters.image_size, config.hyperparameters.image_size), interpolation=1), transforms.ToTensor() ]) # Get data loaders test_loaders_list = dataset_utils.dataloaders.get_testevaluators( config, data_transform, batch_size, test_folds, nrof_folds, ['bbt_ep01']) plotter = utils.VisdomPlotter(config.visdom.server, env_name='evaluation', port=config.visdom.port) if not test_loaders_list: print('No datasets selected for evaluation.') print('Evaluation terminated.') exit(0) # Launch evaluation for test_name, test_loader, eval_function in test_loaders_list: print('\nEvaluation on {}'.format(test_name)) eval_function(test_loader, model, device, test_name, plotter=plotter,
argparser.add_argument('--lr', default=1e-4, type=float) argparser.add_argument('--smoothing_epsilon', default=0.1, type=float) argparser.add_argument('--save_path', default='transformer/', type=str) argparser.add_argument('--plot_attention', default=False, type=ast.literal_eval) argparser.add_argument('--eval_step', default=10, type=int) argparser.add_argument('--max_epochs', default=500, type=int) argparser.add_argument('--num_device', default=0, type=int) argparser.add_argument('--logfile', default='_transformer_experiments_logs.txt', type=str) args = argparser.parse_args() # logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.basicConfig(filename=args.logfile, filemode='a', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') settings = u.populate_configuration(settings, vars(args)) global plotter plotter = u.VisdomPlotter(env_name='Transformer Experiments') if not os.path.isdir(settings['save_path']): os.makedirs(settings['save_path']) launch_experiment(settings)
with open(args.config) as json_config_file: config = utils.AttrDict(json.load(json_config_file)) print('Description of video {}.'.format(config.dataset.movie.movie_path)) print('CONFIGURATION:\t{}'.format(args.config)) # Load model print('Loading model from checkpoint {}'.format(config.model.checkpoint_path)) checkpoint = torch.load(config.model.checkpoint_path) embedding_size = checkpoint['embedding_size'] # CUDA for PyTorch use_cuda = torch.cuda.is_available() device = torch.device("cuda:0" if use_cuda else "cpu") model = models.load_model(config.model.model_arch, device, embedding_size=embedding_size) model.load_state_dict(checkpoint['model_state_dict']) plotter = utils.VisdomPlotter(config.visdom.server, env_name='video_annotation', port=config.visdom.port) vd_utils.annotate_video(config.dataset.movie.movie_path, config.dataset.movie.dataset_path, config.output.video_dir, model, device, max_frame=config.dataset.movie.num_frame, tracker_max_age=config.hyperparameters.tracker_max_age, plotter=plotter)
import numpy as np import utils import pandas as pd import argparse import pickle import os parser = argparse.ArgumentParser( description='Consistency driven Multi-Lable Image Classification') parser.add_argument('--name', default='', type=str, help='Performance filename') args = parser.parse_args() plotter = utils.VisdomPlotter(env_name=args.name) paramFile = os.path.join('runs', args.name, "parameters.csv") perfFile = os.path.join('runs', args.name, "performance.csv") mediaFile = os.path.join('runs', args.name, "media.pkl") # Display parameters paramsDict = {} for line in open(paramFile): key, value = line.split(',') paramsDict.update({key: value}) plotter.argsTile(paramsDict) # Display performance performanceDF = pd.read_csv(perfFile, sep=',', header=0)
argparser.add_argument('--max_dec_in_seq_len', default=600, type=int) argparser.add_argument('--scaling', default=True, type=ast.literal_eval) argparser.add_argument('--lr', default=1e-4, type=float) argparser.add_argument('--save_path', default='pretraining/', type=str) argparser.add_argument('--eval_step', default=10, type=int) argparser.add_argument('--train_score_step', default=2, type=int) argparser.add_argument('--max_epochs', default=50, type=int) argparser.add_argument('--logfile', default='_transformer_pretraining_logs.txt', type=str) args = argparser.parse_args() # logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.basicConfig(filename=args.logfile, filemode='a', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') settings = u.populate_configuration(settings, vars(args)) global plotter plotter = u.VisdomPlotter(env_name='Pretrainer Plots') if not os.path.isdir(settings['save_path']): os.mkdir(settings['save_path']) rep = input('Start Transformer Parrot Pretraining? (y or n): ') if rep == 'y': pretrain_transformer_parrot(settings)
type=int, help='Ratio of Train BS to test BS') args = parser.parse_args() device = torch.device('cuda') # torch.manual_seed(0) # torch.cuda.manual_seed(0) # torch.backends.cudnn.deterministic = True # torch.backends.cudnn.benchmark = False # np.random.seed(0) torch.backends.cudnn.benchmark = True plotter = None if args.plot == True: plotter = utils.VisdomPlotter(env_name=args.name, modality='twoStream') plotter.argsTile(args.__dict__) # Ready the training and validation data dataset = dataDef.twoStreamDataset(args.modality1, args.modality2) trainSampler, validationSampler = dataDef.testTrainSplit( len(dataset), args.valRatio) trainLoader = torch.utils.data.DataLoader(dataset, sampler=trainSampler, batch_size=args.batchSize, num_workers=8) valLoader = torch.utils.data.DataLoader(dataset, sampler=validationSampler, batch_size=args.trainTestBS * args.batchSize, num_workers=8)
def main(args): print('CONFIGURATION:\t{}'.format(args.config)) with open(args.config) as json_config_file: config = utils.AttrDict(json.load(json_config_file)) # Set up output directory # subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') subdir = config.visdom.environment_name model_dir = os.path.join(os.path.expanduser(config.output.output_dir), subdir) if not os.path.isdir(model_dir): # Create the model directory if it doesn't exist os.makedirs(model_dir) else: raise Exception('Environment name {} already taken.'.format(subdir)) config_filename = path_leaf(args.config) copyfile(args.config, os.path.join(model_dir, config_filename)) # CUDA for PyTorch use_cuda = torch.cuda.is_available() device = torch.device("cuda:0" if use_cuda else "cpu") data_transform = transforms.Compose([ transforms.Resize((config.hyperparameters.image_size, config.hyperparameters.image_size), interpolation=1), transforms.ToTensor() ]) test_batch_size = (config.hyperparameters.people_per_batch * config.hyperparameters.images_per_person) // 2 nrof_folds = config.dataset.cross_validation.num_fold fold_tool = utils.FoldGenerator(nrof_folds, config.dataset.cross_validation.num_train_folds, config.dataset.cross_validation.num_val_folds) train_folds, val_folds, test_folds = fold_tool.get_fold() ########################### # SET UP DATALOADERS HERE # ########################### source_loader = dataset_utils.get_coxs2v_trainset(config.dataset.coxs2v.still_dir, config.dataset.coxs2v.video2_dir, config.dataset.coxs2v.video2_pairs, train_folds, nrof_folds, data_transform, config.hyperparameters.people_per_batch, config.hyperparameters.images_per_person) target_loader = dataset_utils.get_coxs2v_trainset(config.dataset.coxs2v.still_dir, config.dataset.coxs2v.video4_dir, config.dataset.coxs2v.video4_pairs, val_folds, nrof_folds, data_transform, config.hyperparameters.people_per_batch, config.hyperparameters.images_per_person) test_loaders_list = dataloaders.get_testevaluators(config, data_transform, test_batch_size, test_folds, nrof_folds, is_vggface2=False, is_lfw=True, is_cox_video1=False, is_cox_video2=True, is_cox_video3=False, is_cox_video4=True) ################### # DATALOADERS END # ################### #Set up training model print('Building training model') if config.model.checkpoint: print('Loading from checkpoint {}'.format(config.model.checkpoint_path)) checkpoint = torch.load(config.model.checkpoint_path) embedding_size = checkpoint['embedding_size'] # start_epoch = checkpoint['epoch'] start_epoch = 0 else: embedding_size = config.model.embedding_size start_epoch = 0 model = models.load_model(config.model.model_arch, embedding_size=embedding_size, imgnet_pretrained=config.model.pretrained_imagenet) optimizer = optim.SGD(model.parameters(), lr=config.hyperparameters.learning_rate, momentum=0.9, nesterov=True, weight_decay=2e-4) scheduler = lr_scheduler.ExponentialLR(optimizer, config.hyperparameters.learning_rate_decay_factor) if config.model.checkpoint: model.load_state_dict(checkpoint['model_state_dict']) # optimizer.load_state_dict(checkpoint['optimizer_state_dict']) # scheduler.load_state_dict(checkpoint['scheduler_state_dict']) model = model.to(device) plotter = utils.VisdomPlotter(env_name=config.visdom.environment_name, port=config.visdom.port) print('Quadruplet loss training mode.') miner = miners.SemihardNegativeQuadrupletSelector(config.hyperparameters.margin) loss = losses.QuadrupletLoss2(config.hyperparameters.margin, config.hyperparameters.margin2, lamda=config.hyperparameters.lamda) trainer = Quadruplet_Trainer(model, miner, loss, optimizer, scheduler, device, plotter, config.hyperparameters.margin, config.model.embedding_size, config.visdom.log_interval) # Loop over epochs print('Training Launched.') for epoch in range(start_epoch, config.hyperparameters.n_epochs): # Validation for test_name, test_loader in test_loaders_list: print('\nEvaluation on {}'.format(test_name)) trainer.Evaluate(test_loader, name=test_name, nrof_folds=nrof_folds, val_far=config.hyperparameters.val_far) # Training print('\nTrain Epoch {}'.format(epoch)) trainer.Train_Epoch(source_loader, target_loader) # Save model if not (epoch + 1) % config.output.save_interval: if not os.path.isdir(model_dir): # Create the model directory if it doesn't exist os.makedirs(model_dir) model_file_path = os.path.join(model_dir, 'model_{}.pth'.format(epoch)) print('\nSave model at {}'.format(model_file_path)) torch.save({'epoch': epoch, 'model_state_dict': utils.state_dict_to_cpu(model.state_dict()), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'embedding_size': config.model.embedding_size }, model_file_path) print('Finish.')
type=int, help='Ratio of Train BS to test BS') args = parser.parse_args() device = torch.device('cuda') # torch.manual_seed(0) # torch.cuda.manual_seed(0) # torch.backends.cudnn.deterministic = True # torch.backends.cudnn.benchmark = False # np.random.seed(0) torch.backends.cudnn.benchmark = True plotter = None if args.plot == True: plotter = utils.VisdomPlotter(env_name=args.name, modality='finalNet') plotter.argsTile(args.__dict__) # Ready the training and validation data dataset = dataDef.twoStreamDataset(args.modality1, args.modality1) trainSampler, validationSampler = dataDef.testTrainSplit( len(dataset), args.valRatio) trainLoader = torch.utils.data.DataLoader(dataset, sampler=trainSampler, batch_size=args.batchSize, num_workers=8) valLoader = torch.utils.data.DataLoader(dataset, sampler=validationSampler, batch_size=args.trainTestBS * args.batchSize, num_workers=8)
def main(args): print('Feature extractor training.') print('CONFIGURATION:\t{}'.format(args.config)) with open(args.config) as json_config_file: config = utils.AttrDict(json.load(json_config_file)) # Set up output directory experiment_name = generate_experiment_name(config) model_dir = os.path.join(os.path.expanduser(config.output.output_dir), experiment_name) if not os.path.exists(model_dir): os.makedirs(model_dir) print('Model saved at {}'.format(model_dir)) config_filename = path_leaf(args.config) copyfile(args.config, os.path.join(model_dir, config_filename)) # CUDA for PyTorch use_cuda = torch.cuda.is_available() device = torch.device("cuda:0" if use_cuda else "cpu") source_loader = dataloaders.get_traindataloaders(config.source_dataset, config) target_loader = dataloaders.get_traindataloaders(config.target_dataset, config) evaluators_list = dataloaders.get_evaluators(config.evaluation_datasets, config) # Set up training model print('Building training model') if config.model.checkpoint: checkpoint_path = config.model.checkpoint_path else: checkpoint_path = None model = models.load_model(config.model.model_arch, device, checkpoint_path=checkpoint_path, embedding_size=config.model.embedding_size, imgnet_pretrained=config.model.pretrained_imagenet) optimizer = optim.SGD(model.parameters(), lr=config.hyperparameters.learning_rate, momentum=0.9, nesterov=True, weight_decay=2e-4) scheduler = lr_scheduler.ExponentialLR(optimizer, config.hyperparameters.learning_rate_decay_factor) model = model.to(device) plotter = utils.VisdomPlotter(config.visdom.server ,env_name=experiment_name, port=config.visdom.port) print('Fitting source dataset.') gmixture = clustering.distance_supervised_gaussian_mixture(source_loader, model, device, _plotter=plotter, name='Source Gaussians') print('Fitting target dataset.') clustering.update_gaussian_mixture(gmixture, target_loader, model, device, _plotter=plotter, name='Target Gaussians') print('DualTriplet loss training mode.') miner = miners.get_miner(config.miner, config.hyperparameters.margin, config.hyperparameters.people_per_batch, plotter, deadzone_ratio=config.hyperparameters.deadzone_ratio) miner.gmixture = gmixture loss = losses.DualtripletLoss(config.hyperparameters.margin, config.hyperparameters.lamda, plotter) model_trainer = trainer.Dualtriplet_Trainer(model, miner, loss, optimizer, scheduler, device, plotter, config.hyperparameters.margin, config.model.embedding_size, batch_size=config.hyperparameters.batch_size) if not os.path.isdir(model_dir): # Create the model directory if it doesn't exist os.makedirs(model_dir) # Loop over epochs epoch = 0 print('Training Launched.') while epoch < config.hyperparameters.n_epochs: # Validation for evaluator in evaluators_list: print('\nEvaluation on {}'.format(evaluator.test_name)) evaluator.evaluate(model, device, plotter=plotter, epoch=epoch) # Training print('\nExperimentation {}'.format(config.experiment)) print('Train Epoch {}'.format(epoch)) model_trainer.Train_Epoch(source_loader, target_loader, epoch) # Save model # if not (epoch + 1) % config.output.save_interval: # # model_file_path = os.path.join(model_dir, 'model_{}.pth'.format(epoch)) # print('\nSave model at {}'.format(model_file_path)) # torch.save({'epoch': epoch, # 'model_state_dict': utils.state_dict_to_cpu(model.state_dict()), # 'optimizer_state_dict': optimizer.state_dict(), # 'scheduler_state_dict': scheduler.state_dict(), # 'embedding_size': config.model.embedding_size # }, model_file_path) epoch += 1 model_file_path = os.path.join(model_dir, 'model_{}.pth'.format(epoch)) print('\nSave model at {}'.format(model_file_path)) torch.save({'epoch': epoch, 'model_state_dict': utils.state_dict_to_cpu(model.state_dict()), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'embedding_size': config.model.embedding_size }, model_file_path) print('Finish.')
def main(args): print('Feature extractor training.') print('CONFIGURATION:\t{}'.format(args.config)) with open(args.config) as json_config_file: config = utils.AttrDict(json.load(json_config_file)) # Set up output directory experiment_name = generate_experiment_name(config) model_dir = os.path.join(os.path.expanduser(config.output.output_dir), experiment_name) if not os.path.exists(model_dir): os.makedirs(model_dir) print('Model saved at {}'.format(model_dir)) config_filename = utils.path_leaf(args.config) copyfile(args.config, os.path.join(model_dir, config_filename)) # CUDA for PyTorch use_cuda = torch.cuda.is_available() device = torch.device("cuda:0" if use_cuda else "cpu") # device = torch.device("cpu") # Get dataloaders train_loader = dataloaders.get_traindataloaders(config.train_dataset, config) evaluators_list = dataloaders.get_evaluators(config.evaluation_datasets, config) # Set up training model print('Building training model') if config.model.checkpoint: checkpoint_path = config.model.checkpoint_path else: checkpoint_path = None model = models.load_model(config.model.model_arch, device, checkpoint_path=checkpoint_path, embedding_size=config.model.embedding_size, imgnet_pretrained=config.model.pretrained_imagenet) optimizer = optim.SGD(model.parameters(), lr=config.hyperparameters.learning_rate, momentum=0.9, nesterov=True, weight_decay=2e-4) # scheduler = lr_scheduler.StepLR(optimizer, 5, gamma=0.1) # scheduler = lr_scheduler.ExponentialLR(optimizer, config.hyperparameters.learning_rate_decay_factor) scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=config.hyperparameters.n_epochs, eta_min=1e-6) plotter = utils.VisdomPlotter(config.visdom.server, env_name=experiment_name, port=config.visdom.port) miner = miners.FunctionSemihardTripletSelector(config.hyperparameters.margin, plotter) loss = nn.TripletMarginLoss(config.hyperparameters.margin, swap=config.hyperparameters.triplet_swap) my_trainer = trainer.Triplet_Trainer(model, miner, loss, optimizer, scheduler, device, plotter, config.hyperparameters.margin, config.model.embedding_size, evaluation.pair_evaluate, batch_size=config.hyperparameters.batch_size) # Loop over epochs epoch = 0 print('Training Launched.') while epoch < config.hyperparameters.n_epochs: # Validation for evaluator in evaluators_list: print('\nEvaluation on {}'.format(evaluator.test_name)) evaluator.evaluate(model, device, plotter=plotter, epoch=epoch) # Training print('\nTrain Epoch {}'.format(epoch)) my_trainer.Train_Epoch(train_loader, epoch) # Save model if not (epoch + 1) % config.output.save_interval: model_file_path = os.path.join(model_dir, 'model_{}.pth'.format(epoch)) print('\nSave model at {}'.format(model_file_path)) torch.save({'epoch': epoch, 'model_state_dict': utils.state_dict_to_cpu(model.state_dict()), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'embedding_size': config.model.embedding_size, }, model_file_path) epoch += 1 # Final save. model_file_path = os.path.join(model_dir, 'model_{}.pth'.format(epoch)) print('\nSave model at {}'.format(model_file_path)) torch.save({'epoch': epoch, 'model_state_dict': utils.state_dict_to_cpu(model.state_dict()), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'embedding_size': config.model.embedding_size, }, model_file_path) print('Finish.') return model
type=int, help='Ratio of Train BS to test BS') args = parser.parse_args() device = torch.device('cuda') # torch.manual_seed(0) # torch.cuda.manual_seed(0) # torch.backends.cudnn.deterministic = True # torch.backends.cudnn.benchmark = False # np.random.seed(0) torch.backends.cudnn.benchmark = True plotter = None if args.plot == True: plotter = utils.VisdomPlotter(env_name=args.name, modality=args.modality) plotter.argsTile(args.__dict__) # Ready the training and validation data dataset = dataDef.genericDataset(args.modality) trainSampler, validationSampler = dataDef.testTrainSplit( len(dataset), args.valRatio) trainLoader = torch.utils.data.DataLoader(dataset, sampler=trainSampler, batch_size=args.batchSize, num_workers=8) valLoader = torch.utils.data.DataLoader(dataset, sampler=validationSampler, batch_size=args.trainTestBS * args.batchSize, num_workers=8)