def cal_mae(img_root,gt_dmap_root,model_param_path): ''' Calculate the MAE of the test data. img_root: the root of test image data. gt_dmap_root: the root of test ground truth density-map data. model_param_path: the path of specific mcnn parameters. ''' device=torch.device("cpu") model=CANNet() model.load_state_dict(torch.load(model_param_path)) model.to(device) dataset=CrowdDataset(img_root,gt_dmap_root,8,phase='test') dataloader=torch.utils.data.DataLoader(dataset,batch_size=1,shuffle=False) model.eval() mae=0 with torch.no_grad(): for i,(img,gt_dmap) in enumerate(tqdm(dataloader)): img=img.to(device) gt_dmap=gt_dmap.to(device) # forward propagation et_dmap=model(img) mae+=abs(et_dmap.data.sum()-gt_dmap.data.sum()).item() del img,gt_dmap,et_dmap print("model_param_path:"+model_param_path+" mae:"+str(mae/len(dataloader)))
def estimate_density_map(img_root,gt_dmap_root,model_param_path,index): ''' Show one estimated density-map. img_root: the root of test image data. gt_dmap_root: the root of test ground truth density-map data. model_param_path: the path of specific mcnn parameters. index: the order of the test image in test dataset. ''' device=torch.device("cuda") model=CANNet().to(device) model.load_state_dict(torch.load(model_param_path)) dataset=CrowdDataset(img_root,gt_dmap_root,8,phase='test') dataloader=torch.utils.data.DataLoader(dataset,batch_size=1,shuffle=False) model.eval() for i,(img,gt_dmap) in enumerate(dataloader): if i==index: img=img.to(device) gt_dmap=gt_dmap.to(device) # forward propagation et_dmap=model(img).detach() et_dmap=et_dmap.squeeze(0).squeeze(0).cpu().numpy() print(et_dmap.shape) plt.imshow(et_dmap,cmap=CM.jet) plt.show() break
def estimate_density_map(img_root, gt_dmap_root, model_param_path, index): device = torch.device("cuda") model = CSRNet().to(device) model.load_state_dict(torch.load(model_param_path)) dataset = CrowdDataset(img_root, gt_dmap_root, 8) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False) model.eval() for i, (img, gt_dmap) in enumerate(dataloader): if i == index: img = img.to(device) gt_dmap = gt_dmap.to(device) # forward propagation et_dmap = model(img).detach() et_dmap = et_dmap.squeeze(0).squeeze(0).cpu().numpy() print(et_dmap.shape) plt.imshow(et_dmap, cmap=CM.jet) break
def estimate_density_map(img_root,gt_dmap_root,model_param_path): ''' Show one estimated density-map. img_root: the root of test image data. gt_dmap_root: the root of test ground truth density-map data. model_param_path: the path of specific mcnn parameters. index: the order of the test image in test dataset. ''' model=CANNet().cuda() model.load_state_dict(torch.load(model_param_path)) model.eval() dataset=CrowdDataset(img_root,gt_dmap_root,8,phase='test') dataloader=torch.utils.data.DataLoader(dataset,batch_size=1,shuffle=False) print('dataloader = ',dataloader) for img,gt_dmap,img_name in dataloader: print('img_shape = ',img.shape) st = time.time() img=img.cuda() gt_dmap=gt_dmap.cuda() # forward propagation et_dmap=model(img).detach() et_dmap=et_dmap.squeeze(0).squeeze(0).cpu().numpy() pred_frame = plt.gca() plt.imshow(et_dmap,cmap=CM.jet) plt.show() pred_frame.axes.get_yaxis().set_visible(False) pred_frame.axes.get_xaxis().set_visible(False) pred_frame.spines['top'].set_visible(False) pred_frame.spines['bottom'].set_visible(False) pred_frame.spines['left'].set_visible(False) pred_frame.spines['right'].set_visible(False) plt.savefig( 'result/'+str(img_name)+'_out' + '.png',bbox_inches='tight', pad_inches=0, dpi=200) plt.close() print('tt = ',time.time()-st) break
def main(args): wandb.init(project="crowd", config=args) args = wandb.config # print(args) # vis=visdom.Visdom() torch.cuda.manual_seed(args.seed) model=CANNet().to(args.device) criterion=nn.MSELoss(reduction='sum').to(args.device) # optimizer=torch.optim.SGD(model.parameters(), args.lr, # momentum=args.momentum, # weight_decay=0) optimizer=torch.optim.Adam(model.parameters(), args.lr, weight_decay=args.decay) train_dataset = CrowdDataset(args.train_image_root, args.train_dmap_root, gt_downsample=8, phase='train') train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True) val_dataset = CrowdDataset(args.val_image_root, args.val_dmap_root, gt_downsample=8, phase='test') val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False) if not os.path.exists('./checkpoints'): os.mkdir('./checkpoints') min_mae = 10000 min_epoch = 0 for epoch in tqdm(range(0, args.epochs)): # training phase model.train() model.zero_grad() train_loss = 0 train_mae = 0 train_bar = tqdm(train_loader) for i, (img,gt_dmap) in enumerate(train_bar): # print(img.shape, gt_dmap.shape) img = img.to(args.device) gt_dmap = gt_dmap.to(args.device) # forward propagation et_dmap = model(img) # calculate loss # print(et_dmap.shape, gt_dmap.shape) loss = criterion(et_dmap, gt_dmap) train_loss += loss.item() train_mae += abs(et_dmap.data.sum()-gt_dmap.data.sum()).item() loss = loss/args.gradient_accumulation_steps loss.backward() if (i+1)%args.gradient_accumulation_steps == 0: optimizer.step() model.zero_grad() train_bar.set_postfix(loss=train_loss/(i+1), mae=train_mae/(i+1)) optimizer.step() model.zero_grad() # print("epoch:",epoch,"loss:",epoch_loss/len(dataloader)) torch.save(model.state_dict(),'./checkpoints/epoch_'+str(epoch)+".pth") # testing phase model.eval() val_loss = 0 val_mae = 0 for i, (img,gt_dmap) in enumerate((val_loader)): img = img.to(args.device) gt_dmap = gt_dmap.to(args.device) # forward propagation et_dmap = model(img) loss = criterion(et_dmap, gt_dmap) val_loss += loss.item() val_mae += abs(et_dmap.data.sum()-gt_dmap.data.sum()).item() del img,gt_dmap,et_dmap if val_mae/len(val_loader) < min_mae: min_mae = val_mae/len(val_loader) min_epoch = epoch # print("epoch:" + str(epoch) + " error:" + str(mae/len(val_loader)) + " min_mae:"+str(min_mae) + " min_epoch:"+str(min_epoch)) wandb.log({"loss/train": train_loss/len(train_loader), "mae/train": train_mae/len(train_loader), "loss/val": val_loss/len(val_loader), "mae/val": val_mae/len(val_loader), }, commit=False) # show an image index = random.randint(0, len(val_loader)-1) img, gt_dmap = val_dataset[index] gt_dmap = gt_dmap.squeeze(0).detach().cpu().numpy() wandb.log({"image/img": [wandb.Image(img)]}, commit=False) wandb.log({"image/gt_dmap": [wandb.Image(gt_dmap/(gt_dmap.max())*255, caption=str(gt_dmap.sum()))]}, commit=False) img = img.unsqueeze(0).to(args.device) et_dmap = model(img) et_dmap = et_dmap.squeeze(0).detach().cpu().numpy() wandb.log({"image/et_dmap": [wandb.Image(et_dmap/(et_dmap.max())*255, caption=str(et_dmap.sum()))]}) import time print(time.strftime('%Y.%m.%d %H:%M:%S',time.localtime(time.time())))
workers = 4 seed = time.time() print_freq = 30 vis = visdom.Visdom() device = torch.device(gpu_or_cpu) torch.cuda.manual_seed(seed) model = CANNet().to(device) criterion = nn.MSELoss(size_average=False).to(device) optimizer = torch.optim.SGD(model.parameters(), lr, momentum=momentum, weight_decay=0) # optimizer=torch.optim.Adam(model.parameters(),lr) train_dataset = CrowdDataset(train_image_root, train_dmap_root, gt_downsample=8) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=1, shuffle=True) test_dataset = CrowdDataset(test_image_root, test_dmap_root, gt_downsample=8) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=False) if not os.path.exists('./checkpoints'): os.mkdir('./checkpoints') min_mae = 10000 min_epoch = 0
def cal_mae(img_root, gt_dmap_root): model_path = './saved_models/CSR_Shanghai_A_900.h5' model_name = os.path.basename(model_path).split('.')[0] # 保存图片 if not os.path.exists('./defense_CSR'): os.mkdir('./defense_CSR') if not os.path.exists('./defense_CSR/density_map_adv'): os.mkdir('./defense_CSR/density_map_adv') if not os.path.exists('./defense_CSR/images_adv_patch'): os.mkdir('./defense_CSR/images_adv_patch') if not os.path.exists('./defense_CSR/images_adv_ablated'): os.mkdir('./defense_CSR/images_adv_ablated') model = CSRNet() # model.load_state_dict(torch.load(model_param_path)) trained_model = os.path.join(model_path) load_net(trained_model, model) model.to(device) dataset = CrowdDataset(img_root, gt_dmap_root, 8) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False) model.eval() mae = 0 with torch.no_grad(): for i, (img, gt_dmap) in enumerate(tqdm(dataloader)): patch, mask, patch_shape = init_patch_circle( image_size, patch_size) patch_init = patch.copy() patch_shape_orig = patch_shape img = img.to(device) gt_dmap = gt_dmap.to(device) im_data_var = Variable(img) # 先进行adv_patch添加 if patch_type == 'circle': patch_full, mask_full, _, rx, ry, _ = circle_transform( patch, mask, patch_init, data_shape, patch_shape) patch_full, mask_full = torch.FloatTensor( patch_full), torch.FloatTensor(mask_full) patch_full, mask_full = patch_full.to(device), mask_full.to(device) patch_var, mask_var = Variable(patch_full), Variable(mask_full) # 在image上面生成adv patch adv_tgt_img_var = torch.mul( (1 - mask_var), im_data_var) + torch.mul(mask_var, patch_var) adv_img = adv_tgt_img_var.data.cpu().numpy() # ***************************************************************** # 存adv_patch攻击的img adv_tgt_img = adv_img[0][0] adv_tgt_img = Image.fromarray(adv_tgt_img).convert('RGB') adv_tgt_img.save( './defense_CSR/images_adv_patch/{}.png'.format(full_imgname)) # plt.imsave('./defense_MCNN/images_adv_patch/{}'.format(full_imgname), adv_tgt_img # , format='png', cmap='gray') img_final = random_mask_batch_one_sample(adv_img, keep, reuse_noise=True) img_final_var = Variable(img_final) et_dmap = model(img_final_var) # ************************************************* # 存ablated adv_patch攻击img im_fi = img_final_var.data.detach().cpu().numpy() im_fi_save = im_fi[0][0] plt.imsave( './defense_CSR/images_adv_ablated/{}'.format(full_imgname), im_fi_save, format='png', cmap='gray') density_map = density_map.data.detach().cpu().numpy() adv_out = density_map[0][0] plt.imsave('./defense_CSR/density_map_adv/{}'.format(full_imgname), adv_out, format='png', cmap=cm.plt.jet) mae += abs(et_dmap.data.sum() - gt_dmap.data.sum()).item() del img, gt_dmap, et_dmap print("model_param_path:" + model_param_path + " mae:" + str(mae / len(dataloader)))
steps = [-1,1,100,150] scales = [1,1,1,1] workers = 4 seed = time.time() print_freq = 30 vis=visdom.Visdom() device=torch.device(gpu_or_cpu) torch.cuda.manual_seed(seed) model=CANNet().to(device) criterion=nn.MSELoss(size_average=False).to(device) optimizer=torch.optim.SGD(model.parameters(),lr, momentum=momentum, weight_decay=0) # optimizer=torch.optim.Adam(model.parameters(),lr) train_dataset=CrowdDataset(train_image_root,train_dmap_root,gt_downsample=8,phase='train') train_loader=torch.utils.data.DataLoader(train_dataset,batch_size=1,shuffle=True) test_dataset=CrowdDataset(test_image_root,test_dmap_root,gt_downsample=8,phase='test') test_loader=torch.utils.data.DataLoader(test_dataset,batch_size=1,shuffle=False) if not os.path.exists('./checkpoints'): os.mkdir('./checkpoints') min_mae=10000 min_epoch=0 train_loss_list=[] epoch_list=[] test_error_list=[] for epoch in range(0,epochs): # training phase model.train() epoch_loss=0