def test(args): args.seed = init_random_seed(args.manual_seed) #####################load datasets##################### kdataloader_trn, _, knownclass = get_data_loader(name=args.datasetname, train=True, split=args.split, batch_size=args.batchsize, image_size=args.imgsize) kdataloader_tst, ukdataloader_tst, knownclass = get_data_loader( name=args.datasetname, train=False, split=args.split, batch_size=args.batchsize, image_size=args.imgsize) nclass = len(knownclass) #####################Network Init##################### Encoderrestore = osp.join('results', args.defense, 'snapshots', args.datasetname + '-' + args.split, args.denoisemean, args.adv + str(args.adv_iter), 'Encoder-' + args.defensesnapshot + '.pt') Encoder = init_model(net=DenoiseResnet.ResnetEncoder( denoisemean=args.denoisemean, latent_size=args.latent_size, denoise=args.denoise), init_type=args.init_type, restore=Encoderrestore, parallel_reload=args.parallel_train) NorClsfierrestore = osp.join('results', args.defense, 'snapshots', args.datasetname + '-' + args.split, args.denoisemean, args.adv + str(args.adv_iter), 'NorClsfier-' + args.defensesnapshot + '.pt') NorClsfier = init_model(net=DenoiseResnet.NorClassifier( latent_size=args.latent_size, num_classes=nclass), init_type=args.init_type, restore=NorClsfierrestore, parallel_reload=args.parallel_train) openmax(args, kdataloader_trn, kdataloader_tst, ukdataloader_tst, knownclass, Encoder, NorClsfier)
def main(args): if args.training_type is 'Train': savefilename = osp.join(args.dataset1 + args.dataset2 + args.dataset3 + '1') elif args.training_type is 'Test': savefilename = osp.join( args.tstfile, args.tstdataset + 'to' + args.dataset_target + args.snapshotnum) args.seed = init_random_seed(args.manual_seed) if args.training_type in ['Train', 'Test']: summary_writer = SummaryWriter( osp.join(args.results_path, 'log', savefilename)) saver = Saver(args, savefilename) saver.print_config() ##################### load seed##################### #####################load datasets##################### if args.training_type is 'Train': data_loader1_real = get_dataset_loader(name=args.dataset1, getreal=True, batch_size=args.batchsize) data_loader1_fake = get_dataset_loader(name=args.dataset1, getreal=False, batch_size=args.batchsize) data_loader2_real = get_dataset_loader(name=args.dataset2, getreal=True, batch_size=args.batchsize) data_loader2_fake = get_dataset_loader(name=args.dataset2, getreal=False, batch_size=args.batchsize) data_loader3_real = get_dataset_loader(name=args.dataset3, getreal=True, batch_size=args.batchsize) data_loader3_fake = get_dataset_loader(name=args.dataset3, getreal=False, batch_size=args.batchsize) data_loader_target = get_tgtdataset_loader(name=args.dataset_target, batch_size=args.batchsize) elif args.training_type is 'Test': data_loader_target = get_tgtdataset_loader(name=args.dataset_target, batch_size=args.batchsize) ##################### load models##################### FeatExtmodel = models.create(args.arch_FeatExt) DepthEstmodel = models.create(args.arch_DepthEst) FeatEmbdmodel = models.create(args.arch_FeatEmbd, momentum=args.bn_momentum) if args.training_type is 'Train': FeatExt_restore = None DepthEst_restore = None FeatEmbd_restore = None elif args.training_type is 'Test': FeatExt_restore = osp.join('results', args.tstfile, 'snapshots', args.tstdataset, 'FeatExtor-' + args.snapshotnum + '.pt') FeatEmbd_restore = osp.join('results', args.tstfile, 'snapshots', args.tstdataset, 'FeatEmbder-' + args.snapshotnum + '.pt') DepthEst_restore = None else: raise NotImplementedError('method type [%s] is not implemented' % args.training_type) FeatExtor = init_model(net=FeatExtmodel, init_type=args.init_type, restore=FeatExt_restore, parallel_reload=True) DepthEstor = init_model(net=DepthEstmodel, init_type=args.init_type, restore=DepthEst_restore, parallel_reload=True) FeatEmbder = init_model(net=FeatEmbdmodel, init_type=args.init_type, restore=FeatEmbd_restore, parallel_reload=False) print(">>> FeatExtor <<<") print(FeatExtor) print(">>> DepthEstor <<<") print(DepthEstor) print(">>> FeatEmbder <<<") print(FeatEmbder) ##################### tarining models##################### if args.training_type == 'Train': Train(args, FeatExtor, DepthEstor, FeatEmbder, data_loader1_real, data_loader1_fake, data_loader2_real, data_loader2_fake, data_loader3_real, data_loader3_fake, data_loader_target, summary_writer, saver, savefilename) elif args.training_type in ['Test']: Test(args, FeatExtor, FeatEmbder, data_loader_target, savefilename) else: raise NotImplementedError('method type [%s] is not implemented' % args.training_type)
def main(args): if args.training_type is 'Train': savefilename = osp.join(args.dataset1 + args.dataset2 + args.dataset3 + '1') elif args.training_type is 'Pre_train': savefilename = osp.join(args.dataset_target + '') elif args.training_type is 'Test': savefilename = osp.join(args.tstfile, args.tstdataset + args.snapshotnum) args.seed = init_random_seed(args.manual_seed) if args.training_type in ['Train', 'Pre_train', 'Test']: summary_writer = SummaryWriter( osp.join(args.results_path, 'log', savefilename)) saver = Saver(args, savefilename) saver.print_config() ##################### load seed##################### #####################load datasets##################### if args.training_type is 'Train': data_loader1_real = get_dataset_loader(name=args.dataset1, getreal=True, batch_size=args.batchsize) data_loader1_fake = get_dataset_loader(name=args.dataset1, getreal=False, batch_size=args.batchsize) data_loader2_real = get_dataset_loader(name=args.dataset2, getreal=True, batch_size=args.batchsize) data_loader2_fake = get_dataset_loader(name=args.dataset2, getreal=False, batch_size=args.batchsize) data_loader3_real = get_dataset_loader(name=args.dataset3, getreal=True, batch_size=args.batchsize) data_loader3_fake = get_dataset_loader(name=args.dataset3, getreal=False, batch_size=args.batchsize) data_loader_target = get_tgtdataset_loader(name=args.dataset_target, batch_size=args.batchsize) elif args.training_type is 'Test': data_loader_target = get_tgtdataset_loader(name=args.dataset_target, batch_size=args.batchsize) elif args.training_type is 'Pre_train': data_loader_real = get_dataset_loader(name=args.dataset_target, getreal=True, batch_size=args.batchsize) data_loader_fake = get_dataset_loader(name=args.dataset_target, getreal=False, batch_size=args.batchsize) ##################### load models##################### FeatExtmodel = models.create(args.arch_FeatExt) FeatExtmodel_pre1 = models.create(args.arch_FeatExt) FeatExtmodel_pre2 = models.create(args.arch_FeatExt) FeatExtmodel_pre3 = models.create(args.arch_FeatExt) FeatEmbdmodel = models.create(args.arch_FeatEmbd, embed_size=args.embed_size) DepthEstmodel = models.create(args.arch_DepthEst) Dismodel1 = models.create(args.arch_Dis1) Dismodel2 = models.create(args.arch_Dis2) Dismodel3 = models.create(args.arch_Dis3) if args.training_type is 'Train': FeatExtS1_restore = osp.join('results', 'Pre_train', 'snapshots', args.dataset1, 'DGFA-Ext-final.pt') FeatExtS2_restore = osp.join('results', 'Pre_train', 'snapshots', args.dataset2, 'DGFA-Ext-final.pt') FeatExtS3_restore = osp.join('results', 'Pre_train', 'snapshots', args.dataset3, 'DGFA-Ext-final.pt') FeatExtorS1 = init_model(net=FeatExtmodel_pre1, init_type=args.init_type, restore=FeatExtS1_restore) FeatExtorS2 = init_model(net=FeatExtmodel_pre2, init_type=args.init_type, restore=FeatExtS2_restore) FeatExtorS3 = init_model(net=FeatExtmodel_pre3, init_type=args.init_type, restore=FeatExtS3_restore) Dis_restore1 = None Dis_restore2 = None Dis_restore3 = None FeatExt_restore = None DepthEst_restore = None FeatEmbd_restore = None FeatEmbder = init_model(net=FeatEmbdmodel, init_type=args.init_type, restore=FeatEmbd_restore) elif args.training_type is 'Pre_train': FeatExt_restore = None DepthEst_restore = None Dis_restore1 = None Dis_restore2 = None Dis_restore3 = None elif args.training_type is 'Test': FeatExt_restore = osp.join('results', args.tstfile, 'snapshots', args.tstdataset, 'DGFA-Ext-' + args.snapshotnum + '.pt') DepthEst_restore = osp.join('results', args.tstfile, 'snapshots', args.tstdataset, 'DGFA-Depth-' + args.snapshotnum + '.pt') FeatEmbd_restore = osp.join('results', args.tstfile, 'snapshots', args.tstdataset, 'DGFA-Embd-' + args.snapshotnum + '.pt') FeatEmbder = init_model(net=FeatEmbdmodel, init_type=args.init_type, restore=FeatEmbd_restore) Dis_restore1 = None Dis_restore2 = None Dis_restore3 = None else: raise NotImplementedError('method type [%s] is not implemented' % args.training_type) FeatExtor = init_model(net=FeatExtmodel, init_type=args.init_type, restore=FeatExt_restore) DepthEstor = init_model(net=DepthEstmodel, init_type=args.init_type, restore=DepthEst_restore) Discriminator1 = init_model(net=Dismodel1, init_type=args.init_type, restore=Dis_restore1) Discriminator2 = init_model(net=Dismodel2, init_type=args.init_type, restore=Dis_restore2) Discriminator3 = init_model(net=Dismodel3, init_type=args.init_type, restore=Dis_restore3) print(">>> FeatExtor <<<") print(FeatExtor) print(">>> FeatEmbder <<<") print(FeatEmbder) print(">>> DepthEstor <<<") print(DepthEstor) print(">>> Discriminator <<<") print(Discriminator1) ##################### tarining models##################### if args.training_type is 'Train': Train(args, FeatExtor, DepthEstor, FeatEmbder, Discriminator1, Discriminator2, Discriminator3, FeatExtorS1, FeatExtorS2, FeatExtorS3, data_loader1_real, data_loader1_fake, data_loader2_real, data_loader2_fake, data_loader3_real, data_loader3_fake, data_loader_target, summary_writer, saver, savefilename) elif args.training_type is 'Test': Test(args, FeatExtor, DepthEstor, FeatEmbder, data_loader_target, savefilename) elif args.training_type is 'Pre_train': Pre_train(args, FeatExtor, DepthEstor, data_loader_real, data_loader_fake, summary_writer, saver, savefilename) else: raise NotImplementedError('method type [%s] is not implemented' % args.training_type)
"""Main script for ADDA.""" import os from misc import config as cfg from core import train_src, train_src_rec, train_tgt from misc.evaluate import eval_func from models import Discriminator_feat, Discriminator_img, SythnetClassifier, SythnetEncoder, SythnetGenerator from misc.utils import get_data_loader, init_model, init_random_seed, mkdirs from misc.saver import Saver from logger import Logger from pdb import set_trace as st if __name__ == '__main__': # init random seed init_random_seed(cfg.manual_seed) Saver = Saver() Saver.print_config() logs_path = os.path.join(cfg.model_root, cfg.name, 'logs') mkdirs(logs_path) logger = Logger(logs_path) # load dataset SM src_data_loader = get_data_loader(cfg.src_dataset) src_data_loader_eval = get_data_loader(cfg.src_dataset, train=False) tgt_data_loader = get_data_loader(cfg.tgt_dataset) tgt_data_loader_eval = get_data_loader(cfg.tgt_dataset, train=False) # load dataset UM MU # src_data_loader = get_data_loader(cfg.src_dataset, sample = True) # src_data_loader_eval = get_data_loader(cfg.src_dataset, train=False) # tgt_data_loader = get_data_loader(cfg.tgt_dataset, sample = True)
def train_Ours(args, train_loader, val_loader, knownclass, Encoder, Decoder, NorClsfier, SSDClsfier, summary_writer, saver): seed = init_random_seed(args.manual_seed) criterionCls = nn.CrossEntropyLoss() criterionRec = nn.MSELoss() if args.parallel_train: Encoder = DataParallel(Encoder) Decoder = DataParallel(Decoder) NorClsfier = DataParallel(NorClsfier) SSDClsfier = DataParallel(SSDClsfier) optimizer = optim.Adam( list(Encoder.parameters()) + list(NorClsfier.parameters()) + list(SSDClsfier.parameters()) + list(Decoder.parameters()), lr=args.lr) if args.adv is 'PGDattack': print("**********Defense PGD Attack**********") elif args.adv is 'FGSMattack': print("**********Defense FGSM Attack**********") if args.adv is 'PGDattack': from advertorch.attacks import PGDAttack nor_adversary = PGDAttack(predict1=Encoder, predict2=NorClsfier, nb_iter=args.adv_iter) rot_adversary = PGDAttack(predict1=Encoder, predict2=SSDClsfier, nb_iter=args.adv_iter) elif args.adv is 'FGSMattack': from advertorch.attacks import GradientSignAttack nor_adversary = GradientSignAttack(predict1=Encoder, predict2=NorClsfier) rot_adversary = GradientSignAttack(predict1=Encoder, predict2=SSDClsfier) global_step = 0 # ---------- # Training # ---------- for epoch in range(args.n_epoch): Encoder.train() Decoder.train() NorClsfier.train() SSDClsfier.train() for steps, (orig, label, rot_orig, rot_label) in enumerate(train_loader): label = lab_conv(knownclass, label) orig, label = orig.cuda(), label.long().cuda() rot_orig, rot_label = rot_orig.cuda(), rot_label.long().cuda() with ctx_noparamgrad_and_eval(Encoder): with ctx_noparamgrad_and_eval(NorClsfier): with ctx_noparamgrad_and_eval(SSDClsfier): adv = nor_adversary.perturb(orig, label) rot_adv = rot_adversary.perturb(rot_orig, rot_label) latent_feat = Encoder(adv) norpred = NorClsfier(latent_feat) norlossCls = criterionCls(norpred, label) recon = Decoder(latent_feat) lossRec = criterionRec(recon, orig) ssdpred = SSDClsfier(Encoder(rot_adv)) rotlossCls = criterionCls(ssdpred, rot_label) loss = args.norClsWgt * norlossCls + args.rotClsWgt * rotlossCls + args.RecWgt * lossRec optimizer.zero_grad() loss.backward() optimizer.step() #============ tensorboard the log info ============# lossinfo = { 'loss': loss.item(), 'norlossCls': norlossCls.item(), 'lossRec': lossRec.item(), 'rotlossCls': rotlossCls.item(), } global_step += 1 #============ print the log info ============# if (steps + 1) % args.log_step == 0: errors = OrderedDict([ ('loss', loss.item()), ('norlossCls', norlossCls.item()), ('lossRec', lossRec.item()), ('rotlossCls', rotlossCls.item()), ]) saver.print_current_errors((epoch + 1), (steps + 1), errors) # evaluate performance on validation set periodically if ((epoch + 1) % args.val_epoch == 0): # switch model to evaluation mode Encoder.eval() NorClsfier.eval() running_corrects = 0.0 epoch_size = 0.0 val_loss_list = [] # calculate accuracy on validation set for steps, (images, label) in enumerate(val_loader): label = lab_conv(knownclass, label) images, label = images.cuda(), label.long().cuda() adv = nor_adversary.perturb(images, label) with torch.no_grad(): logits = NorClsfier(Encoder(adv)) _, preds = torch.max(logits, 1) running_corrects += torch.sum(preds == label.data) epoch_size += images.size(0) val_loss = criterionCls(logits, label) val_loss_list.append(val_loss.item()) val_loss_mean = sum(val_loss_list) / len(val_loss_list) val_acc = running_corrects.double() / epoch_size print('Val Acc: {:.4f}, Val Loss: {:.4f}'.format( val_acc, val_loss_mean)) valinfo = { 'Val Acc': val_acc.item(), 'Val Loss': val_loss.item(), } for tag, value in valinfo.items(): summary_writer.add_scalar(tag, value, (epoch + 1)) orig_show = vutils.make_grid(orig, normalize=True, scale_each=True) recon_show = vutils.make_grid(recon, normalize=True, scale_each=True) summary_writer.add_image('Ori_Image', orig_show, (epoch + 1)) summary_writer.add_image('Rec_Image', recon_show, (epoch + 1)) if ((epoch + 1) % args.model_save_epoch == 0): model_save_path = os.path.join(args.results_path, args.training_type, 'snapshots', args.datasetname + '-' + args.split, args.denoisemean, args.adv + str(args.adv_iter)) mkdir(model_save_path) torch.save( Encoder.state_dict(), os.path.join(model_save_path, "Encoder-{}.pt".format(epoch + 1))) torch.save( NorClsfier.state_dict(), os.path.join(model_save_path, "NorClsfier-{}.pt".format(epoch + 1))) torch.save( Decoder.state_dict(), os.path.join(model_save_path, "Decoder-{}.pt".format(epoch + 1))) torch.save(Encoder.state_dict(), os.path.join(model_save_path, "Encoder-final.pt")) torch.save(NorClsfier.state_dict(), os.path.join(model_save_path, "NorClsfier-final.pt")) torch.save(Decoder.state_dict(), os.path.join(model_save_path, "Decoder-final.pt"))
"""Main script for ARDA.""" from core import test, train from misc import params from misc.utils import get_data_loader, init_model, init_random_seed from models import Classifier, Discriminator, Generator if __name__ == '__main__': # init random seed init_random_seed(params.manual_seed) # load dataset src_data_loader = get_data_loader(params.src_dataset) src_data_loader_test = get_data_loader(params.src_dataset, train=False) tgt_data_loader = get_data_loader(params.tgt_dataset) tgt_data_loader_test = get_data_loader(params.tgt_dataset, train=False) # init models classifier = init_model(net=Classifier(), restore=params.c_model_restore) generator = init_model(net=Generator(), restore=params.g_model_restore) critic = init_model(net=Discriminator(input_dims=params.d_input_dims, hidden_dims=params.d_hidden_dims, output_dims=params.d_output_dims), restore=params.d_model_restore) # train models print("=== Training models ===") print(">>> Classifier <<<") print(classifier) print(">>> Generator <<<") print(generator)