print("The best test l2 is {:.3f}".format(test_l2)) print( "==============================================================================" ) if __name__ == '__main__': file = dataset_name + ".json" args = utils.load_params(file) if w > 0: log_file = "attack" + '_' + target_name + '_{}_{}.txt'.format( target_mode, w) else: log_file = "attack" + '_' + target_name + '_{}.txt'.format(target_mode) logger = utils.Tee(os.path.join(save_log_path, log_file), 'w') utils.print_params(args) train_file = args['dataset']['test_file'] test_file = args['dataset']['train_file'] trainloader = utils.init_dataloader(args, train_file, mode="train") testloader = utils.init_dataloader(args, test_file, mode="test") eval_model = utils.get_model(args, "VGG16", "reg") eval_model = torch.nn.DataParallel(eval_model).to(device) utils.load_state_dict(eval_model, eval_path) save_img_path = os.path.join( save_img_path, "attack_{}_{}".format(target_name, target_mode)) os.makedirs(save_img_path, exist_ok=True) main(args, trainloader, testloader, eval_model)
def main(args): print(args) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) track_running_stats = (args.device != 'xla') if args.device == 'cuda': assert torch.cuda.is_available() torch.backends.cudnn.benchmark = True print('Enable cuDNN heuristics!') device = (torch.device(args.device) if args.device in {'cpu', 'cuda'} else xm.xla_device()) if args.device == 'cuda' and args.amp: scaler = amp.GradScaler() else: scaler = None train_loader, test_loader = init_dataloader(args) B = len(args.lr) if args.hfta else 0 model = Resnet18(num_classes=10, B=B, track_running_stats=track_running_stats).to(device) if not args.convergence_test: if B == 0 and args.save_init_model: torch.save(model, args.model_dir) print("model saved! exiting...") exit(0) if args.load_init_model: model.init_load([args.model_dir] * max(1, B)) print('B={} lr={}'.format(B, args.lr)) optimizer = get_hfta_optim_for(optim.Adadelta, B=B)( model.parameters(), lr=args.lr if B > 0 else args.lr[0], ) all_losses = [] epoch_timer = EpochTimer() for epoch in range(args.epochs): epoch_timer.epoch_start(epoch) num_samples_per_epoch, epoch_losses = train(args, model, device, train_loader, optimizer, epoch, B, save_loss=args.convergence_test, scaler=scaler) epoch_timer.epoch_stop(num_samples_per_epoch) if args.convergence_test: all_losses.append(epoch_losses) print('Epoch {} took {} s!'.format(epoch, epoch_timer.epoch_latency(epoch))) if args.convergence_test: all_losses = torch.cat(all_losses, 0).transpose(0, 1).cpu().numpy() print(all_losses.shape) loss_dict = {} for i, lr in enumerate(args.lr): loss_dict[lr] = all_losses[i] data = pd.DataFrame(loss_dict) data.to_csv(os.path.join(args.outf, "convergence.csv")) else: if args.device == 'xla': print(met.metrics_report()) if args.outf is not None: epoch_timer.to_csv(args.outf) if args.eval: test(model, device, test_loader, B) print('All jobs Finished!')
''' pbar = tqdm(total=len(img_list), desc='computing mean pixel value for training dataset...') for img_name in img_list: if img_name.endswith(".png"): path = img_path + "/" + img_name img = Image.open(path) x = np.array(img, dtype=np.float32) / 255. mpv += x.mean(axis=(0,1)) pbar.update() mpv /= len(img_list) pbar.close() ''' mpv = np.array([0.5061, 0.4254, 0.3828]) mpv = torch.tensor(mpv.astype(np.float32).reshape(1, 3, 1, 1)).to(device) data_set, data_loader = init_dataloader(args, file_path, bsize) test_set, test_loader = init_dataloader(args, test_file_path, bsize) # ================================================ # Training Phase 1 # ================================================ lr = 0.0002 G = CompletionNetwork().cuda() g_optimizer = Adam(G.parameters()) G = torch.nn.DataParallel(G) #.cuda() DL = DLWGAN().cuda() DG = DGWGAN().cuda() DL = torch.nn.DataParallel(DL) #.cuda()
net.eval() cnt, acc = 0, 0 for img, label in dataloader: img, label = img.to(device), label.to(device) label = label.view(-1) out_prob = net(img) out_label = torch.argmax(out_prob, dim=1).view(-1) acc += torch.sum(out_label == label).item() cnt += img.size(0) return acc * 100.0 / cnt root_path = "./result/align" model_path = os.path.join(root_path, "result_models/VGG16_reg.tar") model_name = "VGG16" dataset_name = "facescrub" if __name__ == '__main__': file = dataset_name + ".json" args = utils.load_params(file) file_path = args['dataset']['file_path'] print("Use GPU:{}".format(os.environ["CUDA_VISIBLE_DEVICES"])) test_file = os.path.join(file_path, "test_list.txt") testloader = utils.init_dataloader(args, test_file, mode="test") net = utils.get_model(args, model_name) net = torch.nn.DataParallel(net).to(device) utils.load_state_dict(net, model_path) acc = eval_net(net, testloader) print("ACC:{:.2f}".format(acc))
def main(args): print(args) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) track_running_stats = (args.device != 'xla') if args.device == 'cuda': assert torch.cuda.is_available() torch.backends.cudnn.benchmark = True print('Enable cuDNN heuristics!') device = (torch.device(args.device) if args.device in {'cpu', 'cuda'} else xm.xla_device()) if args.device == 'cuda' and args.amp: scaler = amp.GradScaler() else: scaler = None train_loader, test_loader = init_dataloader(args) B = len(args.lr) if args.hfta else 0 model_config = generate_partially_fused_config(args.serial_num) print("Model config:", model_config) normal_block = str_to_class(model_config["normal_block"]) serial_block = str_to_class(model_config["serial_block"]) model = PartiallyFusedResNet( model_config["arch"], normal_block, serial_block, num_classes=10, B=B, track_running_stats=track_running_stats, ).to(device) if len(model.unfused_layers) > 0: model.unfused_to(device) optimizer = get_hfta_optim_for(optim.Adadelta, B=B, partially_fused=True)( model.parameters(), model.get_unfused_parameters(), lr=args.lr if B > 0 else args.lr[0], ) else: optimizer = get_hfta_optim_for(optim.Adadelta, B=B)( model.parameters(), lr=args.lr if B > 0 else args.lr[0], ) epoch_timer = EpochTimer() for epoch in range(args.epochs): epoch_timer.epoch_start(epoch) num_samples_per_epoch, _ = train(args, model, device, train_loader, optimizer, epoch, B, scaler=scaler) epoch_timer.epoch_stop(num_samples_per_epoch) print('Epoch {} took {} s!'.format(epoch, epoch_timer.epoch_latency(epoch))) if args.device == 'xla': print(met.metrics_report()) if args.outf is not None: epoch_timer.to_csv(args.outf) if args.eval: test(model, device, test_loader, B) print('All jobs Finished!')
import torch.optim as optim from utils import init_dataloader, show_image_batch from model import Generator, Discriminator # args n_hidden = 128 noise_dim = 100 img_dim = 28 * 28 batch_size = 256 n_epoch = 256 lr = 0.001 smooth = 0.1 device = 'cuda' if torch.cuda.is_available() else 'cpu' # init datasets data_loader = init_dataloader(batch_size=batch_size) # init generator generator = Generator(noise_dim, n_hidden, img_dim).to(device) optimizer_g = optim.Adam(generator.parameters(), lr=lr) print(generator) # init discriminator discriminator = Discriminator(img_dim, n_hidden).to(device) optimizer_d = optim.Adam(discriminator.parameters(), lr=lr) print(discriminator) # define loss function loss_function = nn.BCELoss() # 测试使用...