def aggregation(data_train, data_test, args, clientIDs, model, optimizer): mean_train_acc, mean_train_loss = AvgrageMeter(), AvgrageMeter() mean_test_acc, mean_test_loss = AvgrageMeter(), AvgrageMeter() initial_weights = copy.deepcopy(model.state_dict()) num_examples = [] weight_dict_list = [] for clientID in clientIDs: model.load_state_dict(initial_weights) model, train_acc, train_loss, test_acc_list, test_loss_list = lstm_train( data_train[clientID], data_test[clientID], args, model, optimizer, 1) num_examples.append(len(data_train[clientID])) # load state_dict for each client weight_dict_list.append(copy.deepcopy(model.state_dict())) mean_train_acc.update(train_acc, 1) mean_train_loss.update(train_loss, 1) mean_test_acc.update(test_acc_list[-1], 1) mean_test_loss.update(test_loss_list[-1], 1) # meta-learning for key in weight_dict_list[0].keys(): for model_id in range(1, len(weight_dict_list)): weight_dict_list[0][key].add_(weight_dict_list[model_id][key]) weight_dict_list[0][key].mul_(args.global_lr / len(clientIDs)).add_( (1 - args.global_lr) * initial_weights[key]) return weight_dict_list[ 0], mean_train_acc.avg, mean_train_loss.avg, mean_test_acc.avg, mean_test_loss.avg
def aggregation(data_train, data_test, args, clientIDs, model, optimizer): mean_train_acc, mean_train_loss = AvgrageMeter(), AvgrageMeter() mean_test_acc, mean_test_loss = AvgrageMeter(), AvgrageMeter() initial_weights = copy.deepcopy(model.state_dict()) num_examples = [] weight_dict_list = [] for clientID in clientIDs: model.load_state_dict(initial_weights) model, train_acc, train_loss, test_acc_list, test_loss_list = client_update( data_train[clientID], data_test[clientID], args, model, optimizer, args.train_epochs) num_examples.append(len(data_train[clientID])) # load state_dict for each client weight_dict_list.append(copy.deepcopy(model.state_dict())) mean_train_acc.update(train_acc, 1) mean_train_loss.update(train_loss, 1) mean_test_acc.update(test_acc_list[-1], 1) mean_test_loss.update(test_loss_list[-1], 1) # fedAveraging for key in weight_dict_list[0].keys(): weight_dict_list[0][key] *= num_examples[0] for model_id in range(1, len(weight_dict_list)): weight_dict_list[0][key].add_(weight_dict_list[model_id][key] * num_examples[model_id]) weight_dict_list[0][key].div_(np.sum(num_examples)) return weight_dict_list[ 0], mean_train_acc.avg, mean_train_loss.avg, mean_test_acc.avg, mean_test_loss.avg
def train(epoch, epochs, train_loader, device, model, criterion, optimizer, scheduler, tensorboard_path): model.train() top1 = AvgrageMeter() model = model.to(device) train_loss = 0.0 for i, data in enumerate(train_loader, 0): # 0是下标起始位置默认为0 inputs, labels, batch_seq_len = data[0].to(device), data[1].to( device), data[2] # 初始为0,清除上个batch的梯度信息 optimizer.zero_grad() outputs, hidden = model(inputs, batch_seq_len) loss = criterion(outputs, labels) loss.backward() optimizer.step() _, pred = outputs.topk(1) prec1, prec2 = accuracy(outputs, labels, topk=(1, 2)) n = inputs.size(0) top1.update(prec1.item(), n) train_loss += loss.item() postfix = { 'train_loss': '%.6f' % (train_loss / (i + 1)), 'train_acc': '%.6f' % top1.avg } train_loader.set_postfix(log=postfix) # ternsorboard 曲线绘制 if os.path.exists(tensorboard_path) == False: os.mkdir(tensorboard_path) writer = SummaryWriter(tensorboard_path) writer.add_scalar('Train/Loss', loss.item(), epoch) writer.add_scalar('Train/Accuracy', top1.avg, epoch) writer.flush() scheduler.step()
def test(validate_loader, device, model, criterion): val_acc = 0.0 model = model.to(device) model.eval() confuse_meter = ConfuseMeter() with torch.no_grad(): # 进行评测的时候网络不更新梯度 val_top1 = AvgrageMeter() validate_loader = tqdm(validate_loader) validate_loss = 0.0 for i, data in enumerate(validate_loader, 0): # 0是下标起始位置默认为0 inputs, labels, batch_seq_len = data[0].to(device), data[1].to( device), data[2] # inputs,labels = data[0],data[1] outputs, _ = model(inputs, batch_seq_len) # loss = criterion(outputs, labels) prec1, prec2 = accuracy(outputs, labels, topk=(1, 2)) n = inputs.size(0) val_top1.update(prec1.item(), n) confuse_meter.update(outputs, labels) # validate_loss += loss.item() postfix = { 'test_acc': '%.6f' % val_top1.avg, 'confuse_acc': '%.6f' % confuse_meter.acc } validate_loader.set_postfix(log=postfix) val_acc = val_top1.avg return confuse_meter
def validate(epoch, validate_loader, device, model, criterion, tensorboard_path): val_acc = 0.0 model = model.to(device) model.eval() with torch.no_grad(): # 进行评测的时候网络不更新梯度 val_top1 = AvgrageMeter() validate_loader = tqdm(validate_loader) validate_loss = 0.0 for i, data in enumerate(validate_loader, 0): # 0是下标起始位置默认为0 inputs, labels, batch_seq_len = data[0].to(device), data[1].to( device), data[2] # inputs,labels = data[0],data[1] outputs, _ = model(inputs, batch_seq_len) loss = criterion(outputs, labels) prec1, prec2 = accuracy(outputs, labels, topk=(1, 2)) n = inputs.size(0) val_top1.update(prec1.item(), n) validate_loss += loss.item() postfix = { 'validate_loss': '%.6f' % (validate_loss / (i + 1)), 'validate_acc': '%.6f' % val_top1.avg } validate_loader.set_postfix(log=postfix) # ternsorboard 曲线绘制 if os.path.exists(tensorboard_path) == False: os.mkdir(tensorboard_path) writer = SummaryWriter(tensorboard_path) writer.add_scalar('Validate/Loss', loss.item(), epoch) writer.add_scalar('Validate/Accuracy', val_top1.avg, epoch) writer.flush() val_acc = val_top1.avg return val_acc
def update_MLP(self): all_archs = torch.zeros(self.max, 6).cuda() all_target = torch.zeros(self.max).cuda() self.MLP.train() for i, structure_father in enumerate(self.group): all_archs[i][:] = torch.tensor([ item for sublist in structure_father.structure for item in sublist ])[:] all_target[i] = structure_father.loss indx = all_target < 15 all_archs = all_archs[indx, :] all_target = all_target[indx] epoch = 20 objs = AvgrageMeter() batch_size = 32 for i in range(epoch): start = (batch_size * i) % all_archs.size(0) end = start + batch_size archs = all_archs[start:end] target = all_target[start:end] output = self.MLP(archs) loss = self.criterion(output, target) self.optimizer.zero_grad() loss.backward() self.optimizer.step() n = archs.size(0) objs.update(loss.item(), n) logInfo = 'MLP: loss = {:.6f},\t'.format(objs.avg) logging.info(logInfo)
def __init__(self, network, w_lr=0.01, w_mom=0.9, w_wd=1e-4, t_lr=0.001, t_wd=3e-3, t_beta=(0.5, 0.999), init_temperature=5.0, temperature_decay=0.965, logger=logging, lr_scheduler={'T_max': 200}, gpus=[0], save_theta_prefix='', save_tb_log=''): assert isinstance(network, FBNet) network.apply(weights_init) network = network.train().cuda() if isinstance(gpus, str): gpus = [int(i) for i in gpus.strip().split(',')] # network = DataParallel(network, gpus) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") network.to(device) self.gpus = gpus self._mod = network theta_params = network.theta mod_params = network.parameters() self.theta = theta_params self.w = mod_params self._tem_decay = temperature_decay self.temp = init_temperature self.logger = logger self.tensorboard = Tensorboard('logs/' + save_tb_log) self.save_theta_prefix = save_theta_prefix self._acc_avg = AvgrageMeter('acc') self._ce_avg = AvgrageMeter('ce') self._lat_avg = AvgrageMeter('lat') self._loss_avg = AvgrageMeter('loss') self._ener_avg = AvgrageMeter('ener') self.w_opt = torch.optim.SGD(mod_params, w_lr, momentum=w_mom, weight_decay=w_wd) self.w_sche = CosineDecayLR(self.w_opt, **lr_scheduler) self.t_opt = torch.optim.Adam(theta_params, lr=t_lr, betas=t_beta, weight_decay=t_wd)
def train_fn(self, optimizer, criterion, loader, device, train=True): """ Training method :param optimizer: optimization algorithm :criterion: loss function :param loader: data loader for either training or testing set :param device: torch device :param train: boolean to indicate if training or test set is used :return: (accuracy, loss) on the data """ score = AvgrageMeter() objs = AvgrageMeter() self.train() t = tqdm(loader) for images, labels in t: images = images.to(device) labels = labels.to(device) optimizer.zero_grad() logits = self(images) loss = criterion(logits, labels) loss.backward() optimizer.step() acc, _ = accuracy(logits, labels, topk=(1, 5)) n = images.size(0) objs.update(loss.item(), n) score.update(acc.item(), n) t.set_description('(=> Training) Loss: {:.4f}'.format(objs.avg)) return score.avg, objs.avg
def eval_fn(self, loader, device, train=False, confusion_m = False, criterion = None): """ Evaluation method :param loader: data loader for either training or testing set :param device: torch device :param train: boolean to indicate if training or test set is used :return: accuracy on the data """ objs = AvgrageMeter() score = AvgrageMeter() self.eval() with torch.no_grad(): for step, (images, labels) in enumerate(loader): images = images.to(device) labels = labels.to(device) outputs = self(images) acc, _ = accuracy(outputs, labels, topk=(1, 5)) score.update(acc.item(), images.size(0)) if(criterion): loss = criterion(outputs, labels) objs.update(loss.item(), images.size(0)) if step % self.report_freq == 0: logging.info('Evaluation | step: %d | accuracy: %f' % (step, score.avg)) return score.avg, objs.avg
def eval_fn(self, loader, device, train=False, confusion_m = False, criterion = None): """ Evaluation method :param loader: data loader for either training or testing set :param device: torch device :param train: boolean to indicate if training or test set is used :return: accuracy on the data """ objs = AvgrageMeter() score = AvgrageMeter() self.eval() t = tqdm(loader) with torch.no_grad(): for images, labels in t: images = images.to(device) labels = labels.to(device) outputs = self(images) acc, _ = accuracy(outputs, labels, topk=(1, 5)) score.update(acc.item(), images.size(0)) if(criterion): loss = criterion(outputs, labels) objs.update(loss.data, images.size(0)) if(confusion_m): # Plot confusion matrix plot_confusion_matrix(labels.cpu(), outputs.topk(1, 1, True, True)[1].cpu(), normalize = True, title='Confusion matrix') t.set_description('(=> Test) Score: {:.4f}'.format(score.avg)) return score.avg, objs.avg
def __init__(self, network, w_lr=0.01, w_mom=0.9, w_wd=1e-4, t_lr=0.001, t_wd=3e-3, t_beta=(0.5, 0.999), init_temperature=5.0, temperature_decay=0.965, logger=logging, lr_scheduler={'T_max': 200}, gpus=[0], save_theta_prefix='', theta_result_path='./theta-result', checkpoints_path='./checkpoints'): assert isinstance(network, FBNet) network.apply(weights_init) network = network.train().cuda() if isinstance(gpus, str): gpus = [int(i) for i in gpus.strip().split(',')] network = DataParallel(network, gpus) self.gpus = gpus self._mod = network theta_params = network.theta mod_params = network.parameters() self.theta = theta_params self.w = mod_params self._tem_decay = temperature_decay self.temp = init_temperature self.logger = logger self.save_theta_prefix = save_theta_prefix if not os.path.exists(theta_result_path): os.makedirs(theta_result_path) self.theta_result_path = theta_result_path if not os.path.exists(checkpoints_path): os.makedirs(checkpoints_path) self.checkpoints_path = checkpoints_path self._acc_avg = AvgrageMeter('acc') self._ce_avg = AvgrageMeter('ce') self._lat_avg = AvgrageMeter('lat') self._loss_avg = AvgrageMeter('loss') self.w_opt = torch.optim.SGD(mod_params, w_lr, momentum=w_mom, weight_decay=w_wd) self.w_sche = CosineDecayLR(self.w_opt, **lr_scheduler) self.t_opt = torch.optim.Adam(theta_params, lr=t_lr, betas=t_beta, weight_decay=t_wd)
def validate(model, device, args, *, all_iters=None, arch_loader=None): assert arch_loader is not None objs = AvgrageMeter() top1 = AvgrageMeter() top5 = AvgrageMeter() loss_function = args.loss_function val_dataloader = args.val_dataloader model.eval() # model.apply(bn_calibration_init) max_val_iters = 0 t1 = time.time() result_dict = {} arch_dict = arch_loader.get_arch_dict() base_model = mutableResNet20(10).cuda() with torch.no_grad(): for key, value in arch_dict.items(): # 每一个网络 max_val_iters += 1 # print('\r ', key, ' iter:', max_val_iters, end='') for data, target in val_dataloader: # 过一遍数据集 target = target.type(torch.LongTensor) data, target = data.to(device), target.to(device) output = model(data, value["arch"]) prec1, prec5 = accuracy(output, target, topk=(1, 5)) print("acc1: ", prec1.item()) n = data.size(0) top1.update(prec1.item(), n) top5.update(prec5.item(), n) tmp_dict = {} tmp_dict['arch'] = value['arch'] tmp_dict['acc'] = top1.avg result_dict[key] = tmp_dict with open("acc_result.json", "w") as f: json.dump(result_dict, f)
def __init__(self, network, w_lr=0.01, w_mom=0.9, w_wd=1e-4, init_temperature=5.0, temperature_decay=0.965, target_lat=0.0, eta=0.1, lmd=2.0, logger=logging, lr_scheduler={'T_max': 200}, gpus=[0], model_save_path="", save_theta_prefix=''): assert isinstance(network, EDNetV2) network.apply(weights_init) network = network.train().cuda() if isinstance(gpus, str): gpus = [int(i) for i in gpus.strip().split(',')] network = DataParallel(network, gpus) self.gpus = gpus self._mod = network mod_params = network.parameters() self._tem_decay = temperature_decay self.temp = init_temperature self.logger = logger self.save_theta_prefix = save_theta_prefix self.eta = eta self.target_lat = target_lat self.lmd = lmd self.model_save_path = model_save_path self.criterion = nn.CrossEntropyLoss().cuda() self._acc_avg = AvgrageMeter('acc') self._ce_avg = AvgrageMeter('ce') self._lat_avg = AvgrageMeter('lat') self._loss_avg = AvgrageMeter('loss') self._valid_acc = [0.0] #self.opt = torch.optim.SGD( # mod_params, # w_lr, # momentum=w_mom, # weight_decay=w_wd) self.opt = torch.optim.Adam(mod_params, w_lr, weight_decay=w_wd) self.sche = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts( self.opt, T_0=1, T_mult=2) #self.sche = CosineDecayLR(self.opt, **lr_scheduler) self.base_lat = None self.input_shape = None
def infer(model): test_data = dset.CIFAR10( root=TestConfig['data_path'], train=False, download=True, transform=data_transforms_cifar10(0, False), ) if DEBUG: sampler = torch.utils.data.sampler.SubsetRandomSampler(list( range(256))) test_queue = torch.utils.data.DataLoader( test_data, sampler=sampler, batch_size=TestConfig['batch_size'], shuffle=False, pin_memory=True, num_workers=16, ) else: test_queue = torch.utils.data.DataLoader( test_data, batch_size=TestConfig['batch_size'], shuffle=False, pin_memory=True, num_workers=16, ) model.eval().cuda() acc_avg = AvgrageMeter('acc') for step, (X, y) in enumerate(test_queue): X = Variable(X, requires_grad=False).cuda() y = Variable(y, requires_grad=False).cuda(non_blocking=True) logits, _ = model(X, TestConfig['drop_path_prob']) pred = torch.argmax(logits, dim=1) acc = torch.sum(pred == y).float() / TestConfig['batch_size'] acc_avg.update(acc) if step % TestConfig['log_freq'] is 0: print(f"test batch {step}: {acc_avg}") print(f"Final test: {acc_avg}")
def eval_one_epoch(): model.eval() acc = 0.0 map_score_list = [] loss_absolute = AvgrageMeter() loss_contra = AvgrageMeter() for i, batch in enumerate(tqdm(val_dataloader)): # get the inputs with torch.no_grad(): data, binary_mask, label = batch data, binary_mask, label = data.cuda(), binary_mask.cuda( ), label.cuda() optimizer.zero_grad() map_score = 0.0 map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( data) absolute_loss = criterion_absolute_loss(map_x, binary_mask) contrastive_loss = criterion_contrastive_loss(map_x, binary_mask) loss = absolute_loss + contrastive_loss n = data.size(0) loss_absolute.update(absolute_loss.data, n) loss_contra.update(contrastive_loss.data, n) map_score = torch.mean(map_x) map_score = 1.0 if map_score > 1 else map_score.item() map_score_list.append(map_score) # need another way to evaluate pred = 1 if map_score > 0.5 else 0 acc += (pred == label.item()) loss_avg = loss_absolute.avg + loss_contra.avg aou = metrics.roc_auc_score(labels, map_score_list) print( 'epoch:%d, Eval: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f, Total Loss: %.4f, AOU: %.4f\n' % (epoch + 1, loss_absolute.avg, loss_contra.avg, loss_avg, aou)) return acc / len(val_dataset), loss_avg, aou, map_score_list
def eval_fn(self, loader, device, train=False): """ Evaluation method :param loader: data loader for either training or testing set :param device: torch device :param train: boolean to indicate if training or test set is used :return: accuracy on the data """ score = AvgrageMeter() self.eval() t = tqdm(loader) with torch.no_grad(): # no gradient needed for images, labels in t: images = images.to(device) labels = labels.to(device) outputs = self(images) acc, _ = accuracy(outputs, labels, topk=(1, 5)) score.update(acc.item(), images.size(0)) t.set_description('(=> Test) Score: {:.4f}'.format(score.avg)) return score.avg
def test(model, data_test_loader): objs = AvgrageMeter() top1 = AvgrageMeter() criterion = torch.nn.CrossEntropyLoss().cuda() model.eval() with torch.no_grad(): for i, (images_test, labels_test) in enumerate(data_test_loader): images_test, labels_test = images_test.cuda(), labels_test.cuda() output_test = model(images_test) loss_test = criterion(output_test, labels_test) prec_test, = accuracy(output_test, labels_test) n_test = images_test.size(0) objs.update(loss_test.item(), n_test) top1.update(prec_test.item(), n_test) if i % 50 == 0: print(f'Finished {i+1}/{len(data_test_loader)}') print(f'Avg Loss = {objs.avg}' f'Test Acc = {top1.avg}')
def train_one_epoch(): model.train() loss_absolute = AvgrageMeter() loss_contra = AvgrageMeter() trange = tqdm(train_dataloader) for i, batch in enumerate(trange): # get the inputs data, binary_mask, label = batch data, binary_mask, label = data.cuda(), binary_mask.cuda(), label.cuda( ) optimizer.zero_grad() # forward + backward + optimize map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model(data) absolute_loss = criterion_absolute_loss(map_x, binary_mask) contrastive_loss = criterion_contrastive_loss(map_x, binary_mask) loss = absolute_loss + contrastive_loss loss.backward() optimizer.step() n = data.size(0) loss_absolute.update(absolute_loss.data, n) loss_contra.update(contrastive_loss.data, n) postfix_dict = { "loss_absolute": absolute_loss.item(), "loss_contra": contrastive_loss.item(), "loss": loss.item() } trange.set_postfix(**postfix_dict) print( 'epoch:%d, Train: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f\n' % (epoch + 1, loss_absolute.avg, loss_contra.avg))
def __init__(self, network, w_lr=0.01, w_mom=0.9, w_wd=1e-4, t_lr=0.001, t_wd=3e-3, t_beta=(0.5, 0.999), init_temperature=5.0, temperature_decay=0.965, logger=logging, lr_scheduler={'T_max' : 200}, gpus=[0], save_theta_prefix='', resource_weight=0.001): assert isinstance(network, SNAS) network.apply(weights_init) network = network.train().cuda() self._criterion = nn.CrossEntropyLoss().cuda() alpha_params = network.arch_parameters() mod_params = network.model_parameters() self.alpha = alpha_params if isinstance(gpus, str): gpus = [int(i) for i in gpus.strip().split(',')] network = DataParallel(network, gpus) self._mod = network self.gpus = gpus self.w = mod_params self._tem_decay = temperature_decay self.temp = init_temperature self.logger = logger self.save_theta_prefix = save_theta_prefix self._resource_weight = resource_weight self._loss_avg = AvgrageMeter('loss') self._acc_avg = AvgrageMeter('acc') self._res_cons_avg = AvgrageMeter('resource-constraint') self.w_opt = torch.optim.SGD( mod_params, w_lr, momentum=w_mom, weight_decay=w_wd) self.w_sche = CosineDecayLR(self.w_opt, **lr_scheduler) self.t_opt = torch.optim.Adam( alpha_params, lr=t_lr, betas=t_beta, weight_decay=t_wd)
def train_fn(self, optimizer, criterion, loader, device, train=True): score = AvgrageMeter() objs = AvgrageMeter() self.train() for step, (images, labels) in enumerate(loader): images = images.to(device) labels = labels.to(device) optimizer.zero_grad() logits = self(images) loss = criterion(logits, labels) loss.backward() optimizer.step() acc, _ = accuracy(logits, labels, topk=(1, 5)) n = images.size(0) objs.update(loss.item(), n) score.update(acc.item(), n) if step % self.report_freq == 0: logging.info('Training | step: %d | loss: %e | accuracy: %f' % (step, objs.avg, score.avg)) return score.avg, objs.avg
def __init__(self, network, w_lr=0.01, w_mom=0.9, w_wd=1e-4, t_lr=0.001, t_wd=3e-3, init_temperature=5.0, temperature_decay=0.965, logger=logging): assert isinstance(network, FBNet) network.train() self._mod = network theta_params = network.theta mod_params = [] for v in network.parameters(): if v not in theta_params: mod_params.append(v) self.theta = theta_params self.w = mod_params self._tem_decay = temperature_decay self.temp = init_temperature self.logger = logger self._acc_avg = AvgrageMeter('acc') self._ce_avg = AvgrageMeter('ce') self._lat_avg = AvgrageMeter('lat') self.w_opt = torch.optim.SGD(mod_params, w_lr, momentum=w_mom, weight_decay=w_wd) self.t_opt = torch.optim.Adam(theta_params, lr=t_lr, betas=(0.5, 0.999), weight_decay=t_wd)
def train_test(): # GPU & log file --> if use DataParallel, please comment this command os.environ["CUDA_VISIBLE_DEVICES"] = "%d" % (args.gpu) isExists = os.path.exists(args.log) if not isExists: os.makedirs(args.log) log_file = open(args.log + '/' + args.log + '_log.txt', 'w') echo_batches = args.echo_batches print("Oulu-NPU, P1:\n ") log_file.write('Oulu-NPU, P1:\n ') log_file.flush() # load the network, load the pre-trained model in UCF101? finetune = args.finetune if finetune == True: print('finetune!\n') else: print('train from scratch!\n') log_file.write('train from scratch!\n') log_file.flush() #model = CDCNpp( basic_conv=Conv2d_cd, theta=0.7) model = CDCNpp(basic_conv=Conv2d_cd, theta=args.theta) #model = CDCN( basic_conv=Conv2d_cd, theta=args.theta) #model = CDCNpp1( basic_conv=Conv2d_cd, theta=args.theta) model = model.cuda() lr = args.lr optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=0.00005) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma) print(model) criterion_absolute_loss = nn.MSELoss().cuda() criterion_contrastive_loss = Contrast_depth_loss().cuda() ACER_save = 1.0 MSELoss_list = [] Contrast_depth_loss_list = [] accuracy_list = [] accuracy1_list = [] total_loss_list = [] for epoch in range(args.epochs): # loop over the dataset multiple times # meanLoss = [] scheduler.step() if (epoch + 1) % args.step_size == 0: lr *= args.gamma loss_absolute = AvgrageMeter() loss_contra = AvgrageMeter() loss_total = AvgrageMeter() model.train() # load random 16-frame clip data every epoch train_data = Spoofing_train("/home/chang/dataset/oulu/train_face1/", transform=transforms.Compose([ RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion() ])) #/home/chang/dataset/oulu/train_face1/ #train_data = Spoofing_train("../../../../trainset", transform=transforms.Compose([RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion()])) dataloader_train = DataLoader(train_data, batch_size=args.batchsize, shuffle=True, num_workers=4) for i, sample_batched in enumerate(dataloader_train): # get the inputs inputs, binary_mask, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['binary_mask'].cuda( ), sample_batched['spoofing_label'].cuda() # inputs, binary_mask, spoof_label = sample_batched['image_x'], sample_batched['binary_mask'], sample_batched['spoofing_label'] optimizer.zero_grad() # forward + backward + optimize map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs) #pdb.set_trace() #pdb.set_trace() absolute_loss = criterion_absolute_loss(map_x, binary_mask) contrastive_loss = criterion_contrastive_loss(map_x, binary_mask) loss = absolute_loss + contrastive_loss #loss.update(loss.item(), n) #total_loss_list.append(loss.item()) loss.backward() optimizer.step() n = inputs.size(0) loss_absolute.update(absolute_loss.data, n) loss_contra.update(contrastive_loss.data, n) loss_total.update(loss.data, n) #total_loss.append(loss.item()) torch.cuda.empty_cache() # if i > 1: # break # print(np.mean(meanLoss)) if i % echo_batches == echo_batches - 1: # print every 50 mini-batches # # visualization # #FeatureMap2Heatmap(x_input, x_Block1, x_Block2, x_Block3, map_x) # # log written print( 'epoch:%d, mini-batch:%3d, lr=%f, Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f' % (epoch + 1, i + 1, lr, loss_absolute.avg, loss_contra.avg)) # #break # # whole epoch average print( 'epoch:%d, Train: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f, loss= %.4f \n' % (epoch + 1, loss_absolute.avg, loss_contra.avg, loss_total.avg)) MSELoss_list.append(loss_absolute.avg) Contrast_depth_loss_list.append(loss_contra.avg) total_loss_list.append(loss_total.avg) log_file.write( 'epoch:%d, Train: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f \n' % (epoch + 1, loss_absolute.avg, loss_contra.avg)) log_file.write('loss= %.4f \n' % loss_total.avg) log_file.flush() threshold = 0.5 # epoch_test = 1 # if epoch>25 and epoch % 5 == 0: if True: model.eval() meanAcT = [] meanAcF = [] with torch.no_grad(): #rootDir = "D:/dataset/oulu/oulu/trainset/" val_data = Spoofing_test("/home/chang/dataset/oulu/dev_face1/", transform=transforms.Compose( [Normaliztion(), ToTensor()])) #/home/chang/dataset/oulu/dev_face1/ #val_data = Spoofing_train("../../../../devset", transform=transforms.Compose([RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion()])) # val_data = Spoofing_valtest(image_dir, transform=transforms.Compose([Normaliztion_valtest(), ToTensor_valtest()])) test_ba = 1 dataloader_val = DataLoader(val_data, batch_size=test_ba, shuffle=False, num_workers=4) # map_score_list = [] num = 0 for i, sample_batched in enumerate(dataloader_val): # # get the inputs inputs, binary_mask, spoof_label = sample_batched[ 'image_x'].cuda(), sample_batched['binary_mask'].cuda( ), sample_batched['spoofing_label'].cuda() # inputs = sample_batched['image_x'].cuda() # binary_mask = sample_batched['binary_mask'].cuda() optimizer.zero_grad() map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs) # map_x shape: batch,N,N #pre_label = 0 for ba in range(test_ba): pre_label = 0 map_score = torch.sum(map_x[ba]) / (32 * 32) if map_score >= threshold: pre_label = 1 if pre_label == spoof_label: num += 1 if spoof_label != 1: meanAcF.append(1 - map_score.item()) else: meanAcT.append(map_score.item()) # print(spoof_label,map_score) torch.cuda.empty_cache() with torch.no_grad(): #rootDir = "D:/dataset/oulu/oulu/trainset/" val_data = Spoofing_test1("/home/chang/dataset/B_face1/", transform=transforms.Compose( [ToTensor(), Normaliztion()])) #val_data = Spoofing_train("../../../../devset", transform=transforms.Compose([RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion()])) # val_data = Spoofing_valtest(image_dir, transform=transforms.Compose([Normaliztion_valtest(), ToTensor_valtest()])) test_ba = 1 dataloader_val1 = DataLoader(val_data, batch_size=test_ba, shuffle=False, num_workers=4) # map_score_list = [] num1 = 0 for i, sample_batched in enumerate(dataloader_val1): # # get the inputs inputs, binary_mask, spoof_label = sample_batched[ 'image_x'].cuda(), sample_batched['binary_mask'].cuda( ), sample_batched['spoofing_label'].cuda() # inputs = sample_batched['image_x'].cuda() # binary_mask = sample_batched['binary_mask'].cuda() optimizer.zero_grad() map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs) # map_x shape: batch,N,N #pre_label = 0 for ba in range(test_ba): pre_label = 0 map_score = torch.sum(map_x[ba]) / (32 * 32) if map_score >= threshold: pre_label = 1 if pre_label == spoof_label: num1 += 1 # print(spoof_label,map_score) torch.cuda.empty_cache() # # save the model until the next improvement print("TP", np.mean(meanAcT)) print("TN", np.mean(meanAcF)) meanAcT = np.array(meanAcT) meanAcF = np.array(meanAcF) TP = len(meanAcT[meanAcT > threshold]) TN = len(meanAcF[meanAcF > 1 - threshold]) acc = (TP + TN) / (len(meanAcF) + len(meanAcT)) accuracy = num / len(dataloader_val) print("ACC", acc, ":T ", TP, ":", len(meanAcT), " F ", TN, ":", len(meanAcF)) print("ACCURACY:", accuracy) accuracy_list.append(accuracy) accuracy1 = num1 / len(dataloader_val1) accuracy1_list.append(accuracy1) print("ACCURACY1:", accuracy1) log_file.write('val: TP= %.4f,:%.4f TN= %.4f,:%.4f ACC=%.4f \n' % (TP, len(meanAcT), TN, len(meanAcF), acc)) log_file.write('ACCURACY = %.4f \n' % accuracy) log_file.write('ACCURACY1 = %.4f \n' % accuracy1) #print(args.log+'/'+args.log) torch.save(model.state_dict(), args.log + '/' + args.log + '_%d.pkl' % (epoch + 1)) # break print('Finished Training') log_file.close() plt.plot(MSELoss_list, label="MSELoss") plt.plot(Contrast_depth_loss_list, label="depth_loss") plt.plot(total_loss_list, label="total_loss") plt.title("loss") plt.legend() plt.show() plt.plot(accuracy_list, label="accuracy") plt.plot(accuracy1_list, label="accuracy1") #plt.plot(total_loss_list, label = "total_loss") plt.title("accuracy") plt.legend() plt.show()
def validate(model, device, args, *, all_iters=None): objs = AvgrageMeter() top1 = AvgrageMeter() top5 = AvgrageMeter() loss_function = args.loss_function val_dataprovider = args.val_dataprovider model.eval() max_val_iters = 250 t1 = time.time() with torch.no_grad(): for _ in range(1, max_val_iters + 1): data, target = val_dataprovider.next() target = target.type(torch.LongTensor) data, target = data.to(device), target.to(device) output = model(data) loss = loss_function(output, target) prec1, prec5 = accuracy(output, target, topk=(1, 5)) n = data.size(0) objs.update(loss.item(), n) top1.update(prec1.item(), n) top5.update(prec5.item(), n) logInfo = 'TEST Iter {}: loss = {:.6f},\t'.format(all_iters, objs.avg) + \ 'Top-1 err = {:.6f},\t'.format(1 - top1.avg / 100) + \ 'Top-5 err = {:.6f},\t'.format(1 - top5.avg / 100) + \ 'val_time = {:.6f}'.format(time.time() - t1) logging.info(logInfo)
def validate(model, device, args): objs = AvgrageMeter() top1 = AvgrageMeter() top5 = AvgrageMeter() loss_function = args.loss_function val_dataloader = args.val_dataloader L = len(val_dataloader) model.eval() with torch.no_grad(): data_iterator = enumerate(val_dataloader) for _ in tqdm(range(250)): _, data = next(data_iterator) target = data[1].type(torch.LongTensor) data, target = data[0].to(device), target.to(device) output = model(data) loss = loss_function(output, target) prec1, prec5 = accuracy(output, target, topk=(1, 5)) n = data.size(0) objs.update(loss.item()) top1.update(prec1.item()) top5.update(prec5.item()) if args.local_rank == 0: logInfo = 'TEST: loss = {:.6f},\t'.format(objs.avg) + \ 'Top-1 err = {:.6f},\t'.format(100 - top1.avg) + \ 'Top-5 err = {:.6f},\t'.format(100 - top5.avg) logging.info(logInfo)
class Trainer(object): """Training network parameters and theta separately. """ def __init__(self, network, w_lr=0.01, w_mom=0.9, w_wd=1e-4, t_lr=0.001, t_wd=3e-3, t_beta=(0.5, 0.999), init_temperature=5.0, temperature_decay=0.965, logger=logging, lr_scheduler={'T_max': 200}, gpus=[0], save_theta_prefix=''): assert isinstance(network, FBNet) network.apply(weights_init) network = network.train().cuda() if isinstance(gpus, str): gpus = [int(i) for i in gpus.strip().split(',')] network = DataParallel(network, gpus) self.gpus = gpus self._mod = network theta_params = network.theta mod_params = network.parameters() self.theta = theta_params self.w = mod_params self._tem_decay = temperature_decay self.temp = init_temperature self.logger = logger self.save_theta_prefix = save_theta_prefix self._acc_avg = AvgrageMeter('acc') self._ce_avg = AvgrageMeter('ce') self._lat_avg = AvgrageMeter('lat') self._loss_avg = AvgrageMeter('loss') self.w_opt = torch.optim.SGD(mod_params, w_lr, momentum=w_mom, weight_decay=w_wd) self.w_sche = CosineDecayLR(self.w_opt, **lr_scheduler) self.t_opt = torch.optim.Adam(theta_params, lr=t_lr, betas=t_beta, weight_decay=t_wd) def train_w(self, input, target, decay_temperature=False): """Update model parameters. """ self.w_opt.zero_grad() loss, ce, lat, acc, energy = self._mod(input, target, self.temp) loss.backward() self.w_opt.step() if decay_temperature: tmp = self.temp self.temp *= self._tem_decay self.logger.info("Change temperature from %.5f to %.5f" % (tmp, self.temp)) return loss.item(), ce.item(), lat.item(), acc.item(), energy.item() def train_t(self, input, target, decay_temperature=False): """Update theta. """ self.t_opt.zero_grad() loss, ce, lat, acc, energy = self._mod(input, target, self.temp) loss.backward() self.t_opt.step() if decay_temperature: tmp = self.temp self.temp *= self._tem_decay self.logger.info("Change temperature from %.5f to %.5f" % (tmp, self.temp)) return loss.item(), ce.item(), lat.item(), acc.item(), energy.item() def decay_temperature(self, decay_ratio=None): tmp = self.temp if decay_ratio is None: self.temp *= self._tem_decay else: self.temp *= decay_ratio self.logger.info("Change temperature from %.5f to %.5f" % (tmp, self.temp)) def _step(self, input, target, epoch, step, log_frequence, func): """Perform one step of training. """ input = input.cuda() target = target.cuda() loss, ce, lat, acc, energy = func(input, target) # Get status batch_size = self._mod.batch_size self._acc_avg.update(acc) self._ce_avg.update(ce) self._lat_avg.update(lat) self._loss_avg.update(loss) if step > 1 and (step % log_frequence == 0): self.toc = time.time() speed = 1.0 * (batch_size * log_frequence) / (self.toc - self.tic) self.logger.info( "Epoch[%d] Batch[%d] Speed: %.6f samples/sec %s %s %s %s" % (epoch, step, speed, self._loss_avg, self._acc_avg, self._ce_avg, self._lat_avg)) map(lambda avg: avg.reset(), [self._loss_avg, self._acc_avg, self._ce_avg, self._lat_avg]) self.tic = time.time() def search(self, train_w_ds, train_t_ds, total_epoch=90, start_w_epoch=10, log_frequence=100): """Search model. """ assert start_w_epoch >= 1, "Start to train w" self.tic = time.time() for epoch in range(start_w_epoch): self.logger.info("Start to train w for epoch %d" % epoch) for step, (input, target) in enumerate(train_w_ds): self._step(input, target, epoch, step, log_frequence, lambda x, y: self.train_w(x, y, False)) self.w_sche.step() # print(self.w_sche.last_epoch, self.w_opt.param_groups[0]['lr']) self.tic = time.time() for epoch in range(total_epoch): self.logger.info("Start to train theta for epoch %d" % (epoch + start_w_epoch)) for step, (input, target) in enumerate(train_t_ds): self._step(input, target, epoch + start_w_epoch, step, log_frequence, lambda x, y: self.train_t(x, y, False)) self.save_theta( './theta-result/%s_theta_epoch_%d.txt' % (self.save_theta_prefix, epoch + start_w_epoch)) self.decay_temperature() self.logger.info("Start to train w for epoch %d" % (epoch + start_w_epoch)) for step, (input, target) in enumerate(train_w_ds): self._step(input, target, epoch + start_w_epoch, step, log_frequence, lambda x, y: self.train_w(x, y, False)) self.w_sche.step() def save_theta(self, save_path='theta.txt'): """Save theta. """ res = [] with open(save_path, 'w') as f: for t in self.theta: t_list = list(t.detach().cpu().numpy()) res.append(t_list) s = ' '.join([str(tmp) for tmp in t_list]) f.write(s + '\n') return res
criterion_absolute_loss = nn.MSELoss().cuda() criterion_contrastive_loss = Contrast_depth_loss().cuda() ACER_save = 1.0 for epoch in range(args.epochs): # loop over the dataset multiple times scheduler.step() if (epoch + 1) % args.step_size == 0: lr *= args.gamma loss_absolute = AvgrageMeter() loss_contra = AvgrageMeter() #top5 = utils.AvgrageMeter() ########################################### ''' train ''' ########################################### model.train() # load random 16-frame clip data every epoch train_data = Spoofing_train(train_list, image_dir, transform=transforms.Compose([RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion()])) dataloader_train = DataLoader(train_data, batch_size=args.batchsize, shuffle=True, num_workers=4) for i, sample_batched in enumerate(dataloader_train): # get the inputs
def train( args, test_mode='intra', ): if not os.path.exists(args.log): os.makedirs(args.log) if not os.path.exists(args.model_save_dir): os.makedirs(args.model_save_dir) log_file = open(args.log + '/' + test_mode + '_log.txt', 'w') print('Start Training !') log_file.write('Start Training !') log_file.flush() model = SingleBackBoneNet() model = model.cuda() if args.gpu else model.cpu() for name, param in model.named_parameters(): print(name) lr = args.lr optimizer = optim.Adam(model.parameters(), lr=lr) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma) focal_lost = FocalLoss(alpha=torch.Tensor([0.5, 5, 50, 20])) focal_lost = focal_lost.cuda() if args.gpu else focal_lost.cpu() macro_f1_lost = MacroF1Loss().cuda() if args.gpu else MacroF1Loss().cpu() ce_weights_lost = CrossEntropyWithWeights(weigths=[0.5, 5, 50, 20]) ce_weights_lost = ce_weights_lost.cuda( ) if args.gpu else ce_weights_lost.cpu() for epoch in range(args.epochs): loss_log = AvgrageMeter() f1_macro_log = AvgrageMeter() precision_macro_log = AvgrageMeter() recall_macro_log = AvgrageMeter() accuracy_log = AvgrageMeter() print("###################### TRAIN #####################") model.train() train_data = Singledata_train_test(train_or_test='train', test_mode=test_mode) dataloader_train = DataLoader(train_data, batch_size=args.batchsize, shuffle=True) for i, sample_batched in enumerate(dataloader_train): inputs, (labels, one_hot_labels) = sample_batched inputs = torch.stack(inputs).permute(1, 0, 2) one_hot_labels = torch.stack(one_hot_labels).transpose(1, 0) if args.gpu: inputs, labels, one_hot_labels = inputs.cuda(), labels.cuda( ), one_hot_labels.cuda() else: inputs, labels, one_hot_labels = inputs.cpu(), labels.cpu( ), one_hot_labels.cpu() optimizer.zero_grad() predict_logits, attention_score = model(inputs.float()) loss=0.9*macro_f1_lost(y_pred=predict_logits, y_true=one_hot_labels.float())\ +0.1*ce_weights_lost(y_pred=predict_logits, y_true=labels.long()) loss.backward() optimizer.step() n = inputs.size(0) predict_labels = torch.argmax(predict_logits, dim=1).cpu().data.numpy() labels = labels.cpu().data.numpy() loss_log.update(loss.cpu().data, n) print(labels) print(predict_labels) f1_macro_log.update( f1_score(y_true=labels, y_pred=predict_labels, average='macro'), n) precision_macro_log.update( precision_score(y_true=labels, y_pred=predict_labels, average='macro'), n) recall_macro_log.update( recall_score(y_true=labels, y_pred=predict_labels, average='macro'), n) accuracy_log.update( accuracy_score(y_true=labels, y_pred=predict_labels), n) if i % args.echo_batches == args.echo_batches - 1: print( 'TRAIN epoch:%d, mini-batch:%3d, lr=%f, Loss= %.4f, f1= %.4f, precision= %.4f, recall= %.4f, acc= %.4f' % (epoch + 1, i + 1, lr, loss_log.avg, f1_macro_log.avg, precision_macro_log.avg, recall_macro_log.avg, accuracy_log.avg)) print( 'epoch:%d, TRAIN : Loss= %.4f, f1= %.4f, precision= %.4f, recall= %.4f\n, acc= %.4f' % (epoch + 1, loss_log.avg, f1_macro_log.avg, precision_macro_log.avg, recall_macro_log.avg, accuracy_log.avg)) log_file.write( 'epoch:%d, TRAIN : Loss= %.4f, f1= %.4f, precision= %.4f, recall= %.4f, acc= %.4f\n' % (epoch + 1, loss_log.avg, f1_macro_log.avg, precision_macro_log.avg, recall_macro_log.avg, accuracy_log.avg)) log_file.flush() scheduler.step() torch.save( model.state_dict(), args.model_save_dir + '/' + 'save_' + str(test_mode) + '_' + str(epoch) + '.pth') print("###################### VAL #####################") model.eval() f1_macro_log_val = AvgrageMeter() precision_macro_log_val = AvgrageMeter() recall_macro_log_val = AvgrageMeter() accuracy_log_val = AvgrageMeter() with torch.no_grad(): val_data = Singledata_train_test(train_or_test='test', test_mode=test_mode) dataloader_val = DataLoader(val_data, batch_size=args.batchsize, shuffle=True) for i, sample_batched in enumerate(dataloader_val): inputs, (labels, one_hot_labels) = sample_batched inputs = torch.stack(inputs).permute(1, 0, 2) one_hot_labels = torch.stack(one_hot_labels).transpose(1, 0) if args.gpu: inputs, labels, one_hot_labels = inputs.cuda( ), labels.cuda(), one_hot_labels.cuda() else: inputs, labels, one_hot_labels = inputs.cpu(), labels.cpu( ), one_hot_labels.cpu() optimizer.zero_grad() n = inputs.size(0) predict_logits, attention_score = model(inputs.float()) predict_labels = torch.argmax(predict_logits, dim=1).cpu().data.numpy() labels = labels.cpu().data.numpy() f1_macro_log_val.update( f1_score(y_true=labels, y_pred=predict_labels, average='macro'), n) precision_macro_log_val.update( precision_score(y_true=labels, y_pred=predict_labels, average='macro'), n) recall_macro_log_val.update( recall_score(y_true=labels, y_pred=predict_labels, average='macro'), n) accuracy_log_val.update( accuracy_score(y_true=labels, y_pred=predict_labels), n) if i % args.echo_batches == args.echo_batches - 1: print( 'VAL epoch:%d, mini-batch:%3d, lr=%f, f1= %.4f, precision= %.4f, recall= %.4f, acc= %.4f' % (epoch + 1, i + 1, lr, f1_macro_log_val.avg, precision_macro_log_val.avg, recall_macro_log_val.avg, accuracy_log_val.avg)) print( 'epoch:%d, VAL : f1= %.4f, precision= %.4f, recall= %.4f, acc= %.4f\n' % (epoch + 1, f1_macro_log_val.avg, precision_macro_log_val.avg, recall_macro_log_val.avg, accuracy_log_val.avg)) log_file.write( 'epoch:%d, VAL : f1= %.4f, precision= %.4f, recall= %.4f, acc= %.4f\n' % (epoch + 1, f1_macro_log_val.avg, precision_macro_log_val.avg, recall_macro_log_val.avg, accuracy_log_val.avg)) log_file.flush()
def train_test(): # GPU & log file --> if use DataParallel, please comment this command #os.environ["CUDA_VISIBLE_DEVICES"] = "%d" % (args.gpu) if args.exp_name == 'None': args.exp_name = time.strftime("%m-%d %H:%M:%S", time.localtime()) args.log = 'exp/{}/{}'.format(args.exp_name, args.log) isExists = os.path.exists(args.log) if not isExists: os.makedirs(args.log) log_file = open(args.log + '_log_P1.txt', 'w') writer = SummaryWriter(args.log + '/runs/') echo_batches = args.echo_batches print(args) log_file.write(str(args) + '\n') log_file.flush() print("Oulu-NPU, P1:\n ") log_file.write('Oulu-NPU, P1:\n ') log_file.flush() # load the network, load the pre-trained model in UCF101? is_load_model = args.is_load_model if is_load_model == True: print('loading model...\n') print(args.model_path) log_file.write('loading model...\n') log_file.write(args.model_path) log_file.flush() model = CDCNpp(basic_conv=Conv2d_cd, theta=0.7) model = nn.DataParallel(model) model = model.cuda() model.load_state_dict(torch.load(args.model_path)) lr = args.lr optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=0.00005) milestones = [ int(step.strip()) for step in args.lr_drop_step.split(' ') ] scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=args.gamma) else: print('train from scratch!\n') log_file.write('train from scratch!\n') log_file.flush() #model = CDCN(basic_conv=Conv2d_cd, theta=0.7) model = CDCNpp(basic_conv=Conv2d_cd, theta=0.7) model = nn.DataParallel(model) model = model.cuda() lr = args.lr optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=0.00005) milestones = [ int(step.strip()) for step in args.lr_drop_step.split(' ') ] scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=args.gamma) # print(model) # log_file.write(str(model)) # log_file.flush() criterion_absolute_loss = nn.MSELoss().cuda() criterion_contrastive_loss = Contrast_depth_loss().cuda() #bandpass_filter_numpy = build_bandpass_filter_numpy(30, 30) # fs, order # 61, 64 ACER_save = 1.0 iteration = 0 for epoch in range(args.epochs): # loop over the dataset multiple times scheduler.step() if epoch < args.start_epochs: continue lr = scheduler.get_lr()[0] loss_absolute = AvgrageMeter() loss_contra = AvgrageMeter() ########################################### ''' train ''' ########################################### model.train() # load random 16-frame clip data every epoch # train_data = Spoofing_train(train_list, train_image_dir, map_dir, transform=transforms.Compose([RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion()])) train_data = Fas_train(train_list, transform=transforms.Compose([ RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion() ])) dataloader_train = DataLoader(train_data, batch_size=args.batchsize, shuffle=True, num_workers=4) print('train_set read done!') for i, sample_batched in enumerate(dataloader_train): iteration += 1 # get the inputs inputs, map_label, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['map_x'].cuda( ), sample_batched['spoofing_label'].cuda() optimizer.zero_grad() # forward + backward + optimize map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs) absolute_loss = criterion_absolute_loss(map_x, map_label) contrastive_loss = criterion_contrastive_loss(map_x, map_label) loss = absolute_loss + contrastive_loss #loss = absolute_loss loss.backward() optimizer.step() n = inputs.size(0) loss_absolute.update(absolute_loss.data, n) loss_contra.update(contrastive_loss.data, n) if i % echo_batches == echo_batches - 1: # print every 50 mini-batches # visualization FeatureMap2Heatmap(x_input, x_Block1, x_Block2, x_Block3, map_x) # log written print( 'epoch:%d, mini-batch:%3d/%4d, lr=%f, Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f' % (epoch + 1, i + 1, len(dataloader_train), lr, loss_absolute.avg, loss_contra.avg)) log_file.write( 'epoch:%d, mini-batch:%3d/%4d, lr=%f, Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f \n' % (epoch + 1, i + 1, len(dataloader_train), lr, loss_absolute.avg, loss_contra.avg)) log_file.flush() writer.add_scalar('loss', loss_absolute.avg + loss_contra.avg, iteration) writer.add_scalar('lr', lr, iteration) # whole epoch average print( 'epoch:%d, Train: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f\n' % (epoch + 1, loss_absolute.avg, loss_contra.avg)) log_file.write( 'epoch:%d, Train: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f \n' % (epoch + 1, loss_absolute.avg, loss_contra.avg)) log_file.flush() # #### validation/test # if epoch <300: # epoch_test = 300 # else: # epoch_test = 5 # #epoch_test = 1 if epoch % args.epoch_test == args.epoch_test - 1: # test every 5 epochs model.eval() with torch.no_grad(): ########################################### ''' val ''' ########################################### # val for threshold # val_data = Spoofing_valtest(val_list, val_image_dir, val_map_dir, transform=transforms.Compose([Normaliztion_valtest(), ToTensor_valtest()])) val_data = Fas_valtest(val_list, transform=transforms.Compose([ Normaliztion_valtest(), ToTensor_valtest() ]), mode='val') dataloader_val = DataLoader(val_data, batch_size=1, shuffle=False, num_workers=8) map_score_list = [] print('start to validate...') for i, sample_batched in enumerate(dataloader_val): # get the inputs inputs, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['spoofing_label'].cuda() val_maps = sample_batched['val_map_x'].cuda( ) # binary map from PRNet optimizer.zero_grad() #pdb.set_trace() map_score = 0.0 for frame_t in range(inputs.shape[1]): map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs[:, frame_t, :, :, :]) score_norm = torch.sum(map_x) / torch.sum( val_maps[:, frame_t, :, :]) map_score += score_norm map_score = map_score / inputs.shape[1] map_score_list.append('{} {}\n'.format( map_score, spoof_label[0][0])) #pdb.set_trace() if i % (len(dataloader_val) // 5) == 0: # visualization FeatureMap2Heatmap(x_input, x_Block1, x_Block2, x_Block3, map_x) # log written print('val ==> epoch:%d, mini-batch:%3d/%4d...' % (epoch + 1, i + 1, len(dataloader_val))) log_file.write( 'val ==> epoch:%d, mini-batch:%3d/%4d...' % (epoch + 1, i + 1, len(dataloader_val))) log_file.flush() map_score_val_filename = args.log + '_map_score_val.txt' with open(map_score_val_filename, 'w') as file: file.writelines(map_score_list) ########################################### ''' test ''' ########################################## # test for ACC test_data = Fas_valtest(test_list, transform=transforms.Compose([ Normaliztion_valtest(), ToTensor_valtest() ]), mode='test') dataloader_test = DataLoader(test_data, batch_size=1, shuffle=False, num_workers=4) map_score_list = [] print('start to test...') for i, sample_batched in enumerate(dataloader_test): # get the inputs inputs, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['spoofing_label'].cuda() test_maps = sample_batched['val_map_x'].cuda( ) # binary map from PRNet optimizer.zero_grad() map_score = 0.0 for frame_t in range(inputs.shape[1]): map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs[:, frame_t, :, :, :]) score_norm = torch.sum(map_x) / torch.sum( test_maps[:, frame_t, :, :]) map_score += score_norm map_score = map_score / inputs.shape[1] map_score_list.append('{} {}\n'.format( map_score, spoof_label[0][0])) if i % (len(dataloader_test) // 5) == 0: # visualization FeatureMap2Heatmap(x_input, x_Block1, x_Block2, x_Block3, map_x) # log written print('test ==> epoch:%d, mini-batch:%3d/%4d...' % (epoch + 1, i + 1, len(dataloader_val))) log_file.write( 'test ==> epoch:%d, mini-batch:%3d/%4d...' % (epoch + 1, i + 1, len(dataloader_val))) log_file.flush() map_score_test_filename = args.log + '_map_score_test.txt' with open(map_score_test_filename, 'w') as file: file.writelines(map_score_list) ############################################################# # performance measurement both val and test ############################################################# val_threshold, test_threshold, val_ACC, val_ACER, test_ACC, test_APCER, test_BPCER, test_ACER, test_ACER_test_threshold = performances( map_score_val_filename, map_score_test_filename) print( 'epoch:%d, Val: val_threshold= %.4f, val_ACC= %.4f, val_ACER= %.4f' % (epoch + 1, val_threshold, val_ACC, val_ACER)) log_file.write( '\n epoch:%d, Val: val_threshold= %.4f, val_ACC= %.4f, val_ACER= %.4f \n' % (epoch + 1, val_threshold, val_ACC, val_ACER)) print( 'epoch:%d, Test: ACC= %.4f, APCER= %.4f, BPCER= %.4f, ACER= %.4f' % (epoch + 1, test_ACC, test_APCER, test_BPCER, test_ACER)) log_file.write( 'epoch:%d, Test: ACC= %.4f, APCER= %.4f, BPCER= %.4f, ACER= %.4f \n' % (epoch + 1, test_ACC, test_APCER, test_BPCER, test_ACER)) log_file.flush() writer.add_scalar('val_ACER', val_ACER, iteration) writer.add_scalar('test_ACER', test_ACER, iteration) # save the model until the next improvement print("saving model to {}".format(args.log + '_%d.pkl'.format(epoch + 1))) log_file.write("saving model to {}".format(args.log + '_%d.pkl' % (epoch + 1))) log_file.flush() torch.save(model.state_dict(), args.log + '_%d.pkl' % (epoch + 1)) print('Finished Training') writer.close() log_file.close()
def train_test(): # GPU & log file --> if use DataParallel, please comment this command #os.environ["CUDA_VISIBLE_DEVICES"] = "%d" % (args.gpu) isExists = os.path.exists(args.log) if not isExists: os.makedirs(args.log) log_file = open(args.log + '/' + args.log + f'_log_{args.protocol}.txt', 'w') echo_batches = args.echo_batches print(f"SIW, {args.protocol}:\n ") log_file.write(f"SIW, {args.protocol}:\n ") log_file.flush() # load the network, load the pre-trained model in UCF101? finetune = args.finetune if finetune == True: print('finetune!\n') log_file.write('finetune!\n') log_file.flush() model = CDCNpp() #model = model.cuda() model = model.to(device[0]) model = nn.DataParallel(model, device_ids=device, output_device=device[0]) model.load_state_dict(torch.load('xxx.pkl')) lr = args.lr optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=0.00005) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma) else: print('train from scratch!\n') log_file.write('train from scratch!\n') log_file.flush() #model = CDCN(basic_conv=Conv2d_cd, theta=0.7) model = CDCNpp(basic_conv=Conv2d_cd, theta=0.7) model = model.cuda() #model = model.to(device[0]) #model = nn.DataParallel(model, device_ids=device, output_device=device[0]) lr = args.lr optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=0.00005) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma) print(model) criterion_absolute_loss = nn.MSELoss().cuda() criterion_contrastive_loss = Contrast_depth_loss().cuda() #bandpass_filter_numpy = build_bandpass_filter_numpy(30, 30) # fs, order # 61, 64 ACER_save = 1.0 for epoch in range(args.epochs): # loop over the dataset multiple times scheduler.step() if (epoch + 1) % args.step_size == 0: lr *= args.gamma loss_absolute = AvgrageMeter() loss_contra = AvgrageMeter() #top5 = utils.AvgrageMeter() ########################################### ''' train ''' ########################################### model.train() # load random 16-frame clip data every epoch #train_data = Spoofing_train(train_list, train_image_dir, map_dir, transform=transforms.Compose([RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion()])) train_data = SiwDataset( "train", dir_path="/storage/alperen/sodecsapp/datasets/SiW/lists", protocol=args.protocol, transform=transforms.Compose([ RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion() ])) #train_data = SodecDataset(dataset_type="train",dir_path="dataset_with_margin",protocol=args.protocol, transform=transforms.Compose([RandomErasing(), RandomHorizontalFlip(), ToTensor(), Normaliztion()])) dataloader_train = DataLoader(train_data, batch_size=args.batchsize, shuffle=True, num_workers=4) for i, sample_batched in enumerate(dataloader_train): # get the inputs inputs, map_label, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['map_x'].cuda( ), sample_batched['spoofing_label'].cuda() optimizer.zero_grad() #pdb.set_trace() # forward + backward + optimize map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs) absolute_loss = criterion_absolute_loss(map_x, map_label) contrastive_loss = criterion_contrastive_loss(map_x, map_label) loss = absolute_loss + contrastive_loss #loss = absolute_loss loss.backward() optimizer.step() n = inputs.size(0) loss_absolute.update(absolute_loss.data, n) loss_contra.update(contrastive_loss.data, n) if i % echo_batches == echo_batches - 1: # print every 50 mini-batches # visualization FeatureMap2Heatmap(x_input, x_Block1, x_Block2, x_Block3, map_x) # log written print( 'epoch:%d, mini-batch:%3d, lr=%f, Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f' % (epoch + 1, i + 1, lr, loss_absolute.avg, loss_contra.avg)) #log_file.write('epoch:%d, mini-batch:%3d, lr=%f, Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f \n' % (epoch + 1, i + 1, lr, loss_absolute.avg, loss_contra.avg)) #log_file.flush() #break # whole epoch average print( 'epoch:%d, Train: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f\n' % (epoch + 1, loss_absolute.avg, loss_contra.avg)) log_file.write( 'epoch:%d, Train: Absolute_Depth_loss= %.4f, Contrastive_Depth_loss= %.4f \n' % (epoch + 1, loss_absolute.avg, loss_contra.avg)) log_file.flush() #### validation/test """ if epoch <300: epoch_test = 300 else: epoch_test = 20 """ epoch_test = 1 if epoch % epoch_test == epoch_test - 1: # test every 5 epochs model.eval() with torch.no_grad(): ########################################### ''' val ''' ########################################### # val for threshold #val_data = Spoofing_valtest(val_list, val_image_dir, val_map_dir, transform=transforms.Compose([Normaliztion_valtest(), ToTensor_valtest()])) val_data = SiwDataset( "dev", dir_path="/storage/alperen/sodecsapp/datasets/SiW/lists", protocol=args.protocol, transform=transforms.Compose( [Normaliztion_valtest(), ToTensor_valtest()])) #val_data = SodecDataset(dataset_type="test",dir_path="dataset_with_margin",protocol=args.protocol,transform=transforms.Compose([Normaliztion_valtest(), ToTensor_valtest()])) dataloader_val = DataLoader(val_data, batch_size=args.batchsize, shuffle=False, num_workers=4) map_score_list = [] for i, sample_batched in enumerate(dataloader_val): # get the inputs inputs, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['spoofing_label'].cuda() val_maps = sample_batched['map_x'].cuda( ) # binary map from PRNet optimizer.zero_grad() #pdb.set_trace() map_score = 0.0 map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs) score_norm = torch.sum(map_x, (1, 2)) for j, score in enumerate(score_norm): map_score_list.append('{} {}\n'.format( score.item(), spoof_label[j].item())) #pdb.set_trace() map_score_val_filename = args.log + '/' + args.protocol + '_map_score_val.txt' with open(map_score_val_filename, 'w') as file: file.writelines(map_score_list) ########################################### ''' test ''' ########################################## # test for ACC #test_data = Spoofing_valtest(test_list, test_image_dir, test_map_dir, transform=transforms.Compose([Normaliztion_valtest(), ToTensor_valtest()])) test_data = SiwDataset( "eval", dir_path="/storage/alperen/sodecsapp/datasets/SiW/lists", protocol=args.protocol, transform=transforms.Compose( [Normaliztion_valtest(), ToTensor_valtest()])) #test_data = SodecDataset(dataset_type="test",dir_path="dataset_with_margin",protocol=args.protocol,transform=transforms.Compose([Normaliztion_valtest(), ToTensor_valtest()])) dataloader_test = DataLoader(test_data, batch_size=args.batchsize, shuffle=False, num_workers=4) map_score_list = [] for i, sample_batched in enumerate(dataloader_test): # get the inputs inputs, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['spoofing_label'].cuda() test_maps = sample_batched['map_x'].cuda( ) # binary map from PRNet optimizer.zero_grad() #pdb.set_trace() map_score = 0.0 map_x, embedding, x_Block1, x_Block2, x_Block3, x_input = model( inputs) score_norm = torch.sum(map_x, (1, 2)) for j, score in enumerate(score_norm): map_score_list.append('{} {}\n'.format( score.item(), spoof_label[j].item())) map_score_test_filename = args.log + '/' + args.protocol + '_map_score_test.txt' with open(map_score_test_filename, 'w') as file: file.writelines(map_score_list) ############################################################# # performance measurement both val and test ############################################################# val_threshold, test_threshold, val_ACC, val_ACER, test_ACC, test_APCER, test_BPCER, test_ACER, test_ACER_test_threshold = performances( map_score_val_filename, map_score_test_filename) print( 'epoch:%d, Val: val_threshold= %.4f, val_ACC= %.4f, val_ACER= %.4f' % (epoch + 1, val_threshold, val_ACC, val_ACER)) log_file.write( '\n epoch:%d, Val: val_threshold= %.4f, val_ACC= %.4f, val_ACER= %.4f \n' % (epoch + 1, val_threshold, val_ACC, val_ACER)) print( 'epoch:%d, Test: ACC= %.4f, APCER= %.4f, BPCER= %.4f, ACER= %.4f' % (epoch + 1, test_ACC, test_APCER, test_BPCER, test_ACER)) #print('epoch:%d, Test: test_threshold= %.4f, test_ACER_test_threshold= %.4f\n' % (epoch + 1, test_threshold, test_ACER_test_threshold)) log_file.write( 'epoch:%d, Test: ACC= %.4f, APCER= %.4f, BPCER= %.4f, ACER= %.4f \n' % (epoch + 1, test_ACC, test_APCER, test_BPCER, test_ACER)) #log_file.write('epoch:%d, Test: test_threshold= %.4f, test_ACER_test_threshold= %.4f \n\n' % (epoch + 1, test_threshold, test_ACER_test_threshold)) log_file.flush() if epoch > 0: #save the model until the next improvement torch.save(model.state_dict(), args.log + '/' + args.log + '_%d.pkl' % (epoch + 1)) print('Finished Training') log_file.close()
def train_test(): isExists = os.path.exists(args.log) if not isExists: os.makedirs(args.log) log_file = open(args.log + '/' + args.log + '_log_P1.txt', 'a') log_file.write('Oulu-NPU, P1:\n ') log_file.flush() print('train from scratch!\n') log_file.write('train from scratch!\n') log_file.write('lr:%.6f, lamda_kl:%.6f , batchsize:%d\n' % (args.lr, args.kl_lambda, args.batchsize)) log_file.flush() model = CDCN_u(basic_conv=Conv2d_cd, theta=0.7) # model = ResNet18_u() model = model.cuda() model = torch.nn.DataParallel(model) lr = args.lr optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=0.00005) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma) print(model) criterion_absolute_loss = nn.MSELoss().cuda() criterion_contrastive_loss = Contrast_depth_loss().cuda() for epoch in range(args.epochs): if (epoch + 1) % args.step_size == 0: lr *= args.gamma loss_absolute_real = AvgrageMeter() loss_absolute_fake = AvgrageMeter() loss_contra_real = AvgrageMeter() loss_contra_fake = AvgrageMeter() loss_kl_real = AvgrageMeter() loss_kl_fake = AvgrageMeter() ########################################### ''' train ''' ########################################### model.train() # load random 16-frame clip data every epoch train_data = Spoofing_train_g(train_list, train_image_dir, train_map_dir, transform=transforms.Compose([ RandomErasing(), RandomHorizontalFlip(), ToTensor(), Cutout(), Normaliztion() ])) train_real_idx, train_fake_idx = train_data.get_idx() batch_sampler = SeparateBatchSampler(train_real_idx, train_fake_idx, batch_size=args.batchsize, ratio=args.ratio) dataloader_train = DataLoader(train_data, num_workers=8, batch_sampler=batch_sampler) for i, sample_batched in enumerate(dataloader_train): # get the inputs inputs, map_label, spoof_label = sample_batched['image_x'].cuda(), sample_batched['map_x'].cuda(), \ sample_batched['spoofing_label'].cuda() optimizer.zero_grad() # forward + backward + optimize mu, logvar, map_x, x_concat, x_Block1, x_Block2, x_Block3, x_input = model( inputs) mu_real = mu[:int(args.batchsize * args.ratio), :, :] logvar_real = logvar[:int(args.batchsize * args.ratio), :, :] map_x_real = map_x[:int(args.batchsize * args.ratio), :, :] map_label_real = map_label[:int(args.batchsize * args.ratio), :, :] absolute_loss_real = criterion_absolute_loss( map_x_real, map_label_real) contrastive_loss_real = criterion_contrastive_loss( map_x_real, map_label_real) kl_loss_real = -(1 + logvar_real - (mu_real - map_label_real).pow(2) - logvar_real.exp()) / 2 kl_loss_real = kl_loss_real.sum(dim=1).sum(dim=1).mean() kl_loss_real = args.kl_lambda * kl_loss_real mu_fake = mu[int(args.batchsize * args.ratio):, :, :] logvar_fake = logvar[int(args.batchsize * args.ratio):, :, :] map_x_fake = map_x[int(args.batchsize * args.ratio):, :, :] map_label_fake = map_label[int(args.batchsize * args.ratio):, :, :] absolute_loss_fake = 0.1 * criterion_absolute_loss( map_x_fake, map_label_fake) contrastive_loss_fake = 0.1 * criterion_contrastive_loss( map_x_fake, map_label_fake) kl_loss_fake = -(1 + logvar_fake - (mu_fake - map_label_fake).pow(2) - logvar_fake.exp()) / 2 kl_loss_fake = kl_loss_fake.sum(dim=1).sum(dim=1).mean() kl_loss_fake = 0.1 * args.kl_lambda * kl_loss_fake absolute_loss = absolute_loss_real + absolute_loss_fake contrastive_loss = contrastive_loss_real + contrastive_loss_fake kl_loss = kl_loss_real + kl_loss_fake loss = absolute_loss + contrastive_loss + kl_loss loss.backward() optimizer.step() n = inputs.size(0) loss_absolute_real.update(absolute_loss_real.data, n) loss_absolute_fake.update(absolute_loss_fake.data, n) loss_contra_real.update(contrastive_loss_real.data, n) loss_contra_fake.update(contrastive_loss_fake.data, n) loss_kl_real.update(kl_loss_real.data, n) loss_kl_fake.update(kl_loss_fake.data, n) scheduler.step() # whole epoch average print( 'epoch:%d, Train: Absolute_loss: real=%.4f,fake=%.4f, ' 'Contrastive_loss: real=%.4f,fake=%.4f, kl_loss: real=%.4f,fake=%.4f' % (epoch + 1, loss_absolute_real.avg, loss_absolute_fake.avg, loss_contra_real.avg, loss_contra_fake.avg, loss_kl_real.avg, loss_kl_fake.avg)) # validation/test if epoch < 200: epoch_test = 200 else: epoch_test = 50 # epoch_test = 1 if epoch % epoch_test == epoch_test - 1: model.eval() with torch.no_grad(): ########################################### ''' val ''' ########################################### # val for threshold val_data = Spoofing_valtest(val_list, val_image_dir, val_map_dir, transform=transforms.Compose([ Normaliztion_valtest(), ToTensor_valtest() ])) dataloader_val = DataLoader(val_data, batch_size=1, shuffle=False, num_workers=4) map_score_list = [] for i, sample_batched in enumerate(dataloader_val): # get the inputs inputs, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['spoofing_label'].cuda() val_maps = sample_batched['val_map_x'].cuda( ) # binary map from PRNet optimizer.zero_grad() mu, logvar, map_x, x_concat, x_Block1, x_Block2, x_Block3, x_input = model( inputs.squeeze(0)) score_norm = mu.sum(dim=1).sum( dim=1) / val_maps.squeeze(0).sum(dim=1).sum(dim=1) map_score = score_norm.mean() map_score_list.append('{} {}\n'.format( map_score, spoof_label[0][0])) map_score_val_filename = args.log + '/' + args.log + '_map_score_val.txt' with open(map_score_val_filename, 'w') as file: file.writelines(map_score_list) ########################################### ''' test ''' ########################################## # test for ACC test_data = Spoofing_valtest(test_list, test_image_dir, test_map_dir, transform=transforms.Compose([ Normaliztion_valtest(), ToTensor_valtest() ])) dataloader_test = DataLoader(test_data, batch_size=1, shuffle=False, num_workers=4) map_score_list = [] for i, sample_batched in enumerate(dataloader_test): # get the inputs inputs, spoof_label = sample_batched['image_x'].cuda( ), sample_batched['spoofing_label'].cuda() test_maps = sample_batched['val_map_x'].cuda() optimizer.zero_grad() mu, logvar, map_x, x_concat, x_Block1, x_Block2, x_Block3, x_input = model( inputs.squeeze(0)) score_norm = mu.sum(dim=1).sum( dim=1) / test_maps.squeeze(0).sum(dim=1).sum(dim=1) map_score = score_norm.mean() map_score_list.append('{} {}\n'.format( map_score, spoof_label[0][0])) map_score_test_filename = args.log + '/' + args.log + '_map_score_test.txt' with open(map_score_test_filename, 'w') as file: file.writelines(map_score_list) ############################################################# # performance measurement both val and test ############################################################# val_threshold, test_threshold, val_ACC, val_ACER, test_ACC, test_APCER, test_BPCER, test_ACER, test_ACER_test_threshold = performances( map_score_val_filename, map_score_test_filename) print( 'epoch:%d, Val: val_threshold= %.4f, val_ACC= %.4f, val_ACER= %.4f' % (epoch + 1, val_threshold, val_ACC, val_ACER)) log_file.write( '\n epoch:%d, Val: val_threshold= %.4f, val_ACC= %.4f, val_ACER= %.4f \n' % (epoch + 1, val_threshold, val_ACC, val_ACER)) print( 'epoch:%d, Test: ACC= %.4f, APCER= %.4f, BPCER= %.4f, ACER= %.4f' % (epoch + 1, test_ACC, test_APCER, test_BPCER, test_ACER)) log_file.write( 'epoch:%d, Test: ACC= %.4f, APCER= %.4f, BPCER= %.4f, ACER= %.4f \n' % (epoch + 1, test_ACC, test_APCER, test_BPCER, test_ACER)) log_file.flush() if epoch % epoch_test == epoch_test - 1: # save the model until the next improvement torch.save(model.state_dict(), args.log + '/' + args.log + '_%d.pkl' % (epoch + 1)) print('Finished Training') log_file.close()