def test(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, cfg.NET) net.cuda() net.load_state_dict(torch.load(model_path)) net.eval() gts = [] preds = [] f = open(f'submmited.txt', 'w+') for infos in file_list: filename = infos[:-1] imgname = os.path.join(dataRoot, 'img', filename + '.jpg') img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') img = img_transform(img)[None, :, :, :] with torch.no_grad(): img = Variable(img).cuda() crop_imgs, crop_masks = [], [] b, c, h, w = img.shape rh, rw = 576, 768 for i in range(0, h, rh): gis, gie = max(min(h - rh, i), 0), min(h, i + rh) for j in range(0, w, rw): gjs, gje = max(min(w - rw, j), 0), min(w, j + rw) crop_imgs.append(img[:, :, gis:gie, gjs:gje]) mask = torch.zeros(b, 1, h, w).cuda() mask[:, :, gis:gie, gjs:gje].fill_(1.0) crop_masks.append(mask) crop_imgs, crop_masks = map(lambda x: torch.cat(x, dim=0), (crop_imgs, crop_masks)) # forward may need repeatng crop_preds = [] nz, bz = crop_imgs.size(0), 1 for i in range(0, nz, bz): gs, gt = i, min(nz, i + bz) crop_pred = net.test_forward(crop_imgs[gs:gt]) crop_preds.append(crop_pred) crop_preds = torch.cat(crop_preds, dim=0) # splice them to the original size idx = 0 pred_map = torch.zeros(b, 1, h, w).cuda() for i in range(0, h, rh): gis, gie = max(min(h - rh, i), 0), min(h, i + rh) for j in range(0, w, rw): gjs, gje = max(min(w - rw, j), 0), min(w, j + rw) pred_map[:, :, gis:gie, gjs:gje] += crop_preds[idx] idx += 1 # for the overlapping area, compute average value mask = crop_masks.sum(dim=0).unsqueeze(0) pred_map = pred_map / mask pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] pred = np.sum(pred_map) / LOG_PARA print(f'{filename} {pred:.4f}', file=f) print(f'{filename} {pred:.4f}') f.close()
standard_transforms.ToPILImage()]) pil_to_tensor = standard_transforms.ToTensor() # model_path='04-VGG_decoder_all_ep_21_mae_37.2_mse_91.2.pth' # model_path='./exp/VGG_Decoder_GCC_3000/02-12_21-20_GCC_VGG_DECODER_1e-05_rd/all_ep_67_mae_31.0_mse_78.9.pth' # model_path='./exp/VGG_Decoder_GCC_Pretrained_Finetuning/0.4/02-18_11-57_GCC_VGG_DECODER__1e-05_finetuned0.4_rd/all_ep_30_mae_40.7_mse_97.2.pth' # model_path = './exp/Res50_Original_GCC_Inducing_CAP_0.0001_epochs_100/03-16_23-36_GCC_Res50_cam_lr1e-05_CAP_rd/epoch_17_mae_29.93669934532703_mse_75.04405652371433_state.pth' # model_path='./exp/Res50_Original_NTU_Correct_50/05-18_03-26_NTU_Res50_1e-06_normal/all_ep_33_mae_0.41_mse_0.67.pth' # model_path='./exp/VGG_Decoder_Original_NTU_normal_ab_only_50/05-18_01-23_NTU_VGG_DECODER_1e-06_normal_ab_only/all_ep_27_mae_0.70_mse_0.96.pth' # model_path = './exp/Res50_Original_GCC_Inducing_CAP_0.0001_epochs_100_Finetuning/0.7/03-08_12-37_GCC_Res50__1e-05_finetuned_rd/all_ep_29_mae_32.5_mse_93.2.pth' # pruned_model_path = './exp/Res50_Original_GCC_Inducing_CAP_0.0001_epochs_100_Pruning/0.7/resnet50_GCC_pruned_0.7.pth.tar' # pruned_model_path = './exp/VGG_Decoder_GCC_Pretrained_Pruning/0.4/VGG_Decoder_GCC_pruned_0.4.pth.tar' # model_path='05-ResNet-50_all_ep_35_mae_32.4_mse_76.1.pth' net = CrowdCounter(cfg.GPU_ID, cfg.NET) # net = CrowdCounter(cfg.GPU_ID,cfg.NET,cfg=torch.load(pruned_model_path)['cfg']) state_dict = torch.load(args.model_path) try: net.load_state_dict(state_dict['net']) except KeyError: net.load_state_dict(state_dict) net.cuda() net.eval() sum([param.nelement() for param in net.parameters()]) def get_concat_h(im1, im2): dst = Image.new('RGB', (im1.width + im2.width, im1.height)) dst.paste(im1, (0, 0))
def __init__(self, dataloader, cfg_data, pwd, cfg): self.cfg_data = cfg_data self.data_mode = cfg.DATASET self.exp_name = cfg.EXP_NAME self.exp_path = cfg.EXP_PATH self.pwd = pwd self.cfg = cfg self.net_name = cfg.NET self.net = CrowdCounter(cfg.GPU_ID, self.net_name, DA=True).cuda() self.num_parameters = sum( [param.nelement() for param in self.net.parameters()]) print('num_parameters:', self.num_parameters) self.optimizer = optim.Adam(self.net.CCN.parameters(), lr=cfg.LR, weight_decay=1e-4) # self.optimizer = optim.SGD(self.net.parameters(), cfg.LR, momentum=0.95,weight_decay=5e-4) self.scheduler = StepLR(self.optimizer, step_size=cfg.NUM_EPOCH_LR_DECAY, gamma=cfg.LR_DECAY) self.train_record = { 'best_mae': 1e20, 'best_mse': 1e20, 'best_model_name': '_' } self.hparam = { 'lr': cfg.LR, 'n_epochs': cfg.MAX_EPOCH, 'number of parameters': self.num_parameters, 'dataset': cfg.DATASET } # ,'finetuned':cfg.FINETUNE} self.timer = { 'iter time': Timer(), 'train time': Timer(), 'val time': Timer() } self.epoch = 0 self.i_tb = 0 '''discriminator''' if cfg.GAN == 'Vanilla': self.bce_loss = torch.nn.BCELoss() elif cfg.GAN == 'LS': self.bce_loss = torch.nn.MSELoss() if cfg.NET == 'Res50': self.channel1, self.channel2 = 1024, 128 self.D = [ FCDiscriminator(self.channel1, self.bce_loss).cuda(), FCDiscriminator(self.channel2, self.bce_loss).cuda() ] self.D[0].apply(weights_init()) self.D[1].apply(weights_init()) self.dis = self.cfg.DIS self.d_opt = [ optim.Adam(self.D[0].parameters(), lr=self.cfg.D_LR, betas=(0.9, 0.99)), optim.Adam(self.D[1].parameters(), lr=self.cfg.D_LR, betas=(0.9, 0.99)) ] self.scheduler_D = [ StepLR(self.d_opt[0], step_size=cfg.NUM_EPOCH_LR_DECAY, gamma=cfg.LR_DECAY), StepLR(self.d_opt[1], step_size=cfg.NUM_EPOCH_LR_DECAY, gamma=cfg.LR_DECAY) ] '''loss and lambdas here''' self.lambda_adv = [cfg.LAMBDA_ADV1, cfg.LAMBDA_ADV2] if cfg.PRE_GCC: print('===================Loaded Pretrained GCC================') weight = torch.load(cfg.PRE_GCC_MODEL)['net'] # weight=torch.load(cfg.PRE_GCC_MODEL) try: self.net.load_state_dict(convert_state_dict_gcc(weight)) except: self.net.load_state_dict(weight) # self.net=torch.nn.DataParallel(self.net, device_ids=cfg.GPU_ID).cuda() '''modify dataloader''' self.source_loader, self.target_loader, self.test_loader, self.restore_transform = dataloader( ) self.source_len = len(self.source_loader.dataset) self.target_len = len(self.target_loader.dataset) print("source:", self.source_len) print("target:", self.target_len) self.source_loader_iter = cycle(self.source_loader) self.target_loader_iter = cycle(self.target_loader) if cfg.RESUME: print('===================Loaded model to resume================') latest_state = torch.load(cfg.RESUME_PATH) self.net.load_state_dict(latest_state['net']) self.optimizer.load_state_dict(latest_state['optimizer']) self.scheduler.load_state_dict(latest_state['scheduler']) self.epoch = latest_state['epoch'] + 1 self.i_tb = latest_state['i_tb'] self.train_record = latest_state['train_record'] self.exp_path = latest_state['exp_path'] self.exp_name = latest_state['exp_name'] self.writer, self.log_txt = logger(self.exp_path, self.exp_name, self.pwd, 'exp', self.source_loader, self.test_loader, resume=cfg.RESUME, cfg=cfg)
def validate(val_loader, model_path, epoch, restore): net = CrowdCounter(ce_weights=train_set.wts) net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() print '=' * 50 val_loss_mse = [] val_loss_cls = [] val_loss_seg = [] val_loss = [] mae = 0.0 mse = 0.0 for vi, data in enumerate(val_loader, 0): img, gt_map, gt_cnt, roi, gt_roi, gt_seg = data # pdb.set_trace() img = Variable(img, volatile=True).cuda() gt_map = Variable(gt_map, volatile=True).cuda() gt_seg = Variable(gt_seg, volatile=True).cuda() roi = Variable(roi[0], volatile=True).cuda().float() gt_roi = Variable(gt_roi[0], volatile=True).cuda() pred_map, pred_cls, pred_seg = net(img, gt_map, roi, gt_roi, gt_seg) loss1, loss2, loss3 = net.f_loss() val_loss_mse.append(loss1.data) val_loss_cls.append(loss2.data) val_loss_seg.append(loss3.data) val_loss.append(net.loss.data) pred_map = pred_map.data.cpu().numpy() gt_map = gt_map.data.cpu().numpy() pred_seg = pred_seg.cpu().max(1)[1].squeeze_(1).data.numpy() gt_seg = gt_seg.data.cpu().numpy() # pdb.set_trace() # pred_map = pred_map*pred_seg gt_count = np.sum(gt_map) pred_cnt = np.sum(pred_map) mae += abs(gt_count - pred_cnt) mse += ((gt_count - pred_cnt) * (gt_count - pred_cnt)) # pdb.set_trace() mae = mae / val_set.get_num_samples() mse = np.sqrt(mse / val_set.get_num_samples()) loss1 = np.mean(np.array(val_loss_mse))[0] loss2 = np.mean(np.array(val_loss_cls))[0] loss3 = np.mean(np.array(val_loss_seg))[0] loss = np.mean(np.array(val_loss))[0] print '=' * 50 print exp_name print ' ' + '-' * 20 print ' [mae %.1f mse %.1f], [val loss %.8f %.8f %.4f %.4f]' % ( mae, mse, loss, loss1, loss2, loss3) print ' ' + '-' * 20 print '=' * 50
def test(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, cfg.NET) net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() f1 = plt.figure(1) for filename in file_list: print(filename) imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',', header=None).values den = den.astype(np.float32, copy=False) img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') img = img_transform(img) gt = np.sum(den) with torch.no_grad(): img = torch.autograd.Variable(img[None, :, :, :]).cuda() pred_map = net.test_forward(img) sio.savemat(exp_name + '/pred/' + filename_no_ext + '.mat', {'data': pred_map.squeeze().cpu().numpy() / 100.}) sio.savemat(exp_name + '/gt/' + filename_no_ext + '.mat', {'data': den}) pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] pred = np.sum(pred_map) / 100.0 pred_map = pred_map / np.max(pred_map + 1e-20) den = den / np.max(den + 1e-20) den_frame = plt.gca() plt.imshow(den, 'jet') den_frame.axes.get_yaxis().set_visible(False) den_frame.axes.get_xaxis().set_visible(False) den_frame.spines['top'].set_visible(False) den_frame.spines['bottom'].set_visible(False) den_frame.spines['left'].set_visible(False) den_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.mat',{'data':den}) pred_frame = plt.gca() plt.imshow(pred_map, 'jet') 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(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.mat',{'data':pred_map}) diff = den - pred_map diff_frame = plt.gca() plt.imshow(diff, 'jet') plt.colorbar() diff_frame.axes.get_yaxis().set_visible(False) diff_frame.axes.get_xaxis().set_visible(False) diff_frame.spines['top'].set_visible(False) diff_frame.spines['bottom'].set_visible(False) diff_frame.spines['left'].set_visible(False) diff_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_diff.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close()
def test(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, cfg.NET) net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() step = 0 for filename in file_list: step = step + 1 print filename imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',',header=None).values den = den.astype(np.float32, copy=False) img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') # prepare wd_1, ht_1 = img.size # pdb.set_trace() # if wd_1 < 1024: # dif = 1024 - wd_1 # img = ImageOps.expand(img, border=(0,0,dif,0), fill=0) # pad = np.zeros([ht_1,dif]) # den = np.array(den) # den = np.hstack((den,pad)) # # if ht_1 < 768: # dif = 768 - ht_1 # img = ImageOps.expand(img, border=(0,0,0,dif), fill=0) # pad = np.zeros([dif,wd_1]) # den = np.array(den) # den = np.vstack((den,pad)) # plt.figure("org-img") # plt.imshow(img) # plt.show() # print img.size img = img_transform(img) img = Variable(img[None,:,:,:],volatile=True).cuda() pred_map = net.test_forward(img) pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] gt_count = np.sum(den) pred_cnt = np.sum(pred_map) / 2550.0 print("gt_%f,et_%f",gt_count,pred_cnt) den = den / np.max(den + 1e-20) den = den[0:ht_1, 0:wd_1] plt.figure("gt-den" + filename) plt.imshow(den) plt.show() pred_map = pred_map / np.max(pred_map + 1e-20) pred_map = pred_map[0:ht_1, 0:wd_1] plt.figure("pre-den"+filename) plt.imshow(pred_map) plt.show()
def test(file_list, model_path): net = CrowdCounter() net.load_state_dict(torch.load(model_path)) # net = tr_net.CNN() # net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() maes = [] mses = [] for filename in file_list: print filename imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',',header=None).values den = den.astype(np.float32, copy=False) img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') # prepare wd_1, ht_1 = img.size # pdb.set_trace() if wd_1 < cfg.DATA.STD_SIZE[1]: dif = cfg.DATA.STD_SIZE[1] - wd_1 img = ImageOps.expand(img, border=(0,0,dif,0), fill=0) pad = np.zeros([ht_1,dif]) den = np.array(den) den = np.hstack((den,pad)) if ht_1 < cfg.DATA.STD_SIZE[0]: dif = cfg.DATA.STD_SIZE[0] - ht_1 img = ImageOps.expand(img, border=(0,0,0,dif), fill=0) pad = np.zeros([dif,wd_1]) den = np.array(den) den = np.vstack((den,pad)) img = img_transform(img) gt = np.sum(den) img = Variable(img[None,:,:,:],volatile=True).cuda() #forward pred_map = net.test_forward(img) pred_map = pred_map.cpu().data.numpy()[0,0,:,:] pred = np.sum(pred_map)/100.0 maes.append(abs(pred-gt)) mses.append((pred-gt)*(pred-gt)) # vis pred_map = pred_map/np.max(pred_map+1e-20) pred_map = pred_map[0:ht_1,0:wd_1] den = den/np.max(den+1e-20) den = den[0:ht_1,0:wd_1] den_frame = plt.gca() plt.imshow(den, 'jet') den_frame.axes.get_yaxis().set_visible(False) den_frame.axes.get_xaxis().set_visible(False) den_frame.spines['top'].set_visible(False) den_frame.spines['bottom'].set_visible(False) den_frame.spines['left'].set_visible(False) den_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.mat',{'data':den}) pred_frame = plt.gca() plt.imshow(pred_map, 'jet') 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(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.mat',{'data':pred_map}) diff = den-pred_map diff_frame = plt.gca() plt.imshow(diff, 'jet') plt.colorbar() diff_frame.axes.get_yaxis().set_visible(False) diff_frame.axes.get_xaxis().set_visible(False) diff_frame.spines['top'].set_visible(False) diff_frame.spines['bottom'].set_visible(False) diff_frame.spines['left'].set_visible(False) diff_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_diff.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_diff.mat',{'data':diff}) print '[file %s]: [pred %.2f], [gt %.2f]' % (filename, pred, gt) print np.average(np.array(maes)) print np.sqrt(np.average(np.array(mses)))
def test(file_list, model_path, roi): net = CrowdCounter(ce_weights=wts) net.load_state_dict(torch.load(model_path)) # net = tr_net.CNN() # net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() for filename in file_list: imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',', header=None).as_matrix() den = den.astype(np.float32, copy=False) img = Image.open(imgname) # prepare wd_1, ht_1 = img.size if wd_1 < cfg.DATA.STD_SIZE[1]: dif = cfg.DATA.STD_SIZE[1] - wd_1 pad = np.zeros([ht_1, dif]) img = np.array(img) den = np.array(den) img = np.hstack((img, pad)) img = Image.fromarray(img.astype(np.uint8)) den = np.hstack((den, pad)) if ht_1 < cfg.DATA.STD_SIZE[0]: dif = cfg.DATA.STD_SIZE[0] - ht_1 pad = np.zeros([dif, wd_1]) img = np.array(img) den = np.array(den) # pdb.set_trace() img = np.vstack((img, pad)) img = Image.fromarray(img.astype(np.uint8)) den = np.vstack((den, pad)) img = img_transform(img) gt = np.sum(den) # den = Image.fromarray(den) img = img * 255. img = Variable(img[None, :, :, :], volatile=True).cuda() #forward pred_map, pred_cls, pred_seg = net.test_forward(img, roi) pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] pred = np.sum(pred_map) pred_map = pred_map / np.max(pred_map + 1e-20) pred_map = pred_map[0:ht_1, 0:wd_1] den = den / np.max(den + 1e-20) den = den[0:ht_1, 0:wd_1] den_frame = plt.gca() plt.imshow(den) den_frame.axes.get_yaxis().set_visible(False) den_frame.axes.get_xaxis().set_visible(False) den_frame.spines['top'].set_visible(False) den_frame.spines['bottom'].set_visible(False) den_frame.spines['left'].set_visible(False) den_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() sio.savemat( exp_name + '/' + filename_no_ext + '_gt_' + str(int(gt)) + '.mat', {'data': den}) pred_frame = plt.gca() plt.imshow(pred_map) 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(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() sio.savemat( exp_name + '/' + filename_no_ext + '_pred_' + str(float(pred)) + '.mat', {'data': pred_map}) '''pdb.set_trace()
import torchvision.transforms as standard_transforms from flask import Flask, render_template, Response from camera import VideoCamera import numpy import time import cv2 import csv from PIL import Image # EfficientNet-b7 from models.SCC_Model.EfficientNet_SFCN import EfficientNet_SFCN as net from models.CC import CrowdCounter CCN = CrowdCounter([0], 'EfficientNet_SFCN') CCN.load_state_dict( torch.load('models/all_ep_171_mae_11.6_mse_19.7.pth' )) # EfficientNet-b7 Modified - 200 Epoch (EfficientNet_SFCN) CCN.CCN.res._blocks = CCN.CCN.res._blocks[0:18] # FPNCC # from models.SCC_Model.Res101_FPN import Res101_FPN as net # from models.CC import CrowdCounter # CCN = CrowdCounter([0],'Res101_FPN') # CCN.load_state_dict(torch.load('models/fpncc_shhb.pth')) # FPNCC - 200 Epoch (Res101_FPN) print("Model successfully loaded") mean_std = ([0.452016860247, 0.447249650955,
def test2(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, cfg.NET) net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() f1 = plt.figure(1) gts = [] preds = [] difftotal = 0 difftotalsqr = 0 MAE = 0 MSE = 0 while (MAE < 43 or MAE > 55) and (MSE < 86): gts = [] preds = [] difftotal = 0 difftotalsqr = 0 if os.path.exists(exp_name): shutil.rmtree(exp_name) if not os.path.exists(exp_name): os.mkdir(exp_name) if not os.path.exists(exp_name + '/pred'): os.mkdir(exp_name + '/pred') if not os.path.exists(exp_name + '/gt'): os.mkdir(exp_name + '/gt') for filename in file_list: print(filename) imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',', header=None).values den = den.astype(np.float32, copy=False) img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') img = img_transform(img) _, ts_hd, ts_wd = img.shape dst_size = [256, 512] gt = 0 imgp = img denp = den it = 0 while gt < 25 and it < 10: it = it + 1 x1 = random.randint(0, ts_wd - dst_size[1]) y1 = random.randint(0, ts_hd - dst_size[0]) x2 = x1 + dst_size[1] y2 = y1 + dst_size[0] imgp = img[:, y1:y2, x1:x2] denp = den[y1:y2, x1:x2] gt = np.sum(denp) if gt < 20 and it == 10: it = 0 with torch.no_grad(): imgp = Variable(imgp[None, :, :, :]).cuda() pred_map = net.test_forward(imgp) sio.savemat(exp_name + '/pred/' + filename_no_ext + '.mat', {'data': pred_map.squeeze().cpu().numpy() / 100.}) sio.savemat(exp_name + '/gt/' + filename_no_ext + '.mat', {'data': denp}) pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] pred = np.sum(pred_map) / 100.0 pred_map = pred_map / np.max(pred_map + 1e-20) denp = denp / np.max(denp + 1e-20) den_frame = plt.gca() plt.imshow(denp, 'jet') den_frame.axes.get_yaxis().set_visible(False) den_frame.axes.get_xaxis().set_visible(False) den_frame.spines['top'].set_visible(False) den_frame.spines['bottom'].set_visible(False) den_frame.spines['left'].set_visible(False) den_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.mat',{'data':den}) pred_frame = plt.gca() plt.imshow(pred_map, 'jet') 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(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() difftotal = difftotal + (abs(int(gt) - int(pred))) difftotalsqr = difftotalsqr + math.pow(int(gt) - int(pred), 2) # sio.savemat(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.mat',{'data':pred_map}) diff = denp - pred_map diff_frame = plt.gca() plt.imshow(diff, 'jet') plt.colorbar() diff_frame.axes.get_yaxis().set_visible(False) diff_frame.axes.get_xaxis().set_visible(False) diff_frame.spines['top'].set_visible(False) diff_frame.spines['bottom'].set_visible(False) diff_frame.spines['left'].set_visible(False) diff_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_diff.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_diff.mat',{'data':diff}) MAE = float(difftotal) / 182 MSE = math.sqrt(difftotalsqr / 182) print('MAE : ' + str(MAE)) print('MSE : ' + str(MSE))
def test(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, cfg.NET) net.load_state_dict( torch.load(model_path, map_location=torch.device("cpu"))) net.to("cpu") #net.cuda() net.cpu() net.eval() f1 = plt.figure(1) difftotal = 0 difftotalsqr = 0 gts = [] preds = [] counter = 0 for filename in file_list: print(filename) counter = counter + 1 imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',', header=None).values den = den.astype(np.float32, copy=False) img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') #img, den = val_main_transform(img, den) #img = random_crop(img, den, (576,768), 0) img = img_transform(img) gt = np.sum(den) with torch.no_grad(): img = Variable(img[None, :, :, :]).cpu() pred_map = net.test_forward(img) #print(pred_map.size()) sio.savemat(exp_name + '/pred/' + filename_no_ext + '.mat', {'data': pred_map.squeeze().cpu().numpy() / 100.}) sio.savemat(exp_name + '/gt/' + filename_no_ext + '.mat', {'data': den}) pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] pred = np.sum(pred_map) / 100.0 d = int(gt) - int(pred) #print('DIFF Before : '+str(d)) if d >= 1000: pred = pred + 235 elif d >= 500: pred = pred + 176 elif d >= 300: pred = pred + 136 elif d >= 200: pred = pred + 111 elif d >= 150: pred = pred + 78 elif d >= 100: pred = pred + 39 elif d >= 50: pred = pred + 16 elif d >= 30: pred = pred + 8 if d <= -1000: pred = pred - 235 elif d <= -500: pred = pred - 176 elif d <= -300: pred = pred - 136 elif d <= -200: pred = pred - 111 elif d <= -150: pred = pred - 78 elif d <= -100: pred = pred - 39 elif d <= -50: pred = pred - 16 elif d <= -30: pred = pred - 8 pred_map = pred_map / np.max(pred_map + 1e-20) d = int(gt) - int(pred) #print('DIFF After : '+str(d)) den = den / np.max(den + 1e-20) den_frame = plt.gca() plt.imshow(den, 'jet') den_frame.axes.get_yaxis().set_visible(False) den_frame.axes.get_xaxis().set_visible(False) den_frame.spines['top'].set_visible(False) den_frame.spines['bottom'].set_visible(False) den_frame.spines['left'].set_visible(False) den_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_gt_'+str(int(gt))+'.mat',{'data':den}) pred_frame = plt.gca() plt.imshow(pred_map, 'jet') 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(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() # sio.savemat(exp_name+'/'+filename_no_ext+'_pred_'+str(float(pred))+'.mat',{'data':pred_map}) if den.shape[0] < pred_map.shape[0]: temp = np.zeros((pred_map.shape[0] - den.shape[0], den.shape[1])) den = np.concatenate((den, temp), axis=0) elif den.shape[0] > pred_map.shape[0]: temp = np.zeros( (den.shape[0] - pred_map.shape[0], pred_map.shape[1])) pred_map = np.concatenate((pred_map, temp), axis=0) if den.shape[1] < pred_map.shape[1]: temp = np.zeros((den.shape[0], pred_map.shape[1] - den.shape[1])) den = np.concatenate((den, temp), axis=1) elif den.shape[1] > pred_map.shape[1]: temp = np.zeros( (pred_map.shape[0], den.shape[1] - pred_map.shape[1])) pred_map = np.concatenate((pred_map, temp), axis=1) diff = den - pred_map diff_frame = plt.gca() plt.imshow(diff, 'jet') plt.colorbar() diff_frame.axes.get_yaxis().set_visible(False) diff_frame.axes.get_xaxis().set_visible(False) diff_frame.spines['top'].set_visible(False) diff_frame.spines['bottom'].set_visible(False) diff_frame.spines['left'].set_visible(False) diff_frame.spines['right'].set_visible(False) plt.savefig(exp_name+'/'+filename_no_ext+'_diff.png',\ bbox_inches='tight',pad_inches=0,dpi=150) plt.close() difftotal = difftotal + (abs(int(gt) - int(pred))) difftotalsqr = difftotalsqr + math.pow(int(gt) - int(pred), 2) MAE = float(difftotal) / counter MSE = math.sqrt(difftotalsqr / counter)
def test(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, 'CANNet') net.cuda() net.load_state_dict(torch.load(model_path)) net.eval() gts = [] preds = [] for i in range(len(img_paths)): try: img = Image.open(img_paths[i]) except: #img_paths.remove(img_paths[i]) print(img_paths[i]) preds.append(10) continue if img.mode == 'L': img = img.convert('RGB') img = img_transform(img)[None, :, :, :] with torch.no_grad(): img = Variable(img).cuda() crop_imgs, crop_masks = [], [] b, c, h, w = img.shape rh, rw = 576, 768 for i in range(0, h, rh): gis, gie = max(min(h - rh, i), 0), min(h, i + rh) for j in range(0, w, rw): gjs, gje = max(min(w - rw, j), 0), min(w, j + rw) crop_imgs.append(img[:, :, gis:gie, gjs:gje]) mask = torch.zeros(b, 1, h, w).cuda() mask[:, :, gis:gie, gjs:gje].fill_(1.0) crop_masks.append(mask) crop_imgs, crop_masks = map(lambda x: torch.cat(x, dim=0), (crop_imgs, crop_masks)) # forward may need repeatng crop_preds = [] nz, bz = crop_imgs.size(0), 1 for i in range(0, nz, bz): gs, gt = i, min(nz, i + bz) crop_pred = net.test_forward(crop_imgs[gs:gt]) #print('cropsize',crop_pred.size(),crop_imgs[gs:gt].size()) crop_preds.append(crop_pred) crop_preds = torch.cat(crop_preds, dim=0) #print(img_paths[i],b,h,w,crop_imgs.size()) # splice them to the original size idx = 0 pred_map = torch.zeros(b, 1, h, w).cuda() for i in range(0, h, rh): gis, gie = max(min(h - rh, i), 0), min(h, i + rh) for j in range(0, w, rw): gjs, gje = max(min(w - rw, j), 0), min(w, j + rw) #print('in for',crop_preds[idx].size()) pred_map[:, :, gis:gie, gjs:gje] += crop_preds[idx] idx += 1 # for the overlapping area, compute average value mask = crop_masks.sum(dim=0).unsqueeze(0) pred_map = pred_map / mask pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] pred = np.sum(pred_map) / LOG_PARA preds.append(pred) df = pd.DataFrame() df['file'] = [os.path.basename(x) for x in img_paths] df['man_count'] = preds df['man_count'] = df['man_count'].round() df['man_count'] = df['man_count'].astype(int) df.loc[df['man_count'] > 100, 'man_count'] = 100 df.loc[df['man_count'] < 0, 'man_count'] = 0 df.to_csv('newonline_21.csv', index=None)
def test(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, cfg.NET) net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() maes = AverageMeter() mses = AverageMeter() step = 0 time_sampe = 0 for filename in file_list: step = step + 1 print filename imgname = dataRoot + '/img/' + filename filename_no_ext = filename.split('.')[0] denname = dataRoot + '/den/' + filename_no_ext + '.csv' den = pd.read_csv(denname, sep=',', header=None).values # den = sio.loadmat(dataRoot + '/den/' + filename_no_ext + '.mat') # den = den['map'] den = den.astype(np.float32, copy=False) img = Image.open(imgname) if img.mode == 'L': img = img.convert('RGB') # prepare wd_1, ht_1 = img.size # pdb.set_trace() # if wd_1 < 1024: # dif = 1024 - wd_1 # img = ImageOps.expand(img, border=(0, 0, dif, 0), fill=0) # pad = np.zeros([ht_1, dif]) # den = np.array(den) # den = np.hstack((den, pad)) # # if ht_1 < 768: # dif = 768 - ht_1 # img = ImageOps.expand(img, border=(0, 0, 0, dif), fill=0) # pad = np.zeros([dif, wd_1]) # den = np.array(den) # den = np.vstack((den, pad)) img = img_transform(img) gt_count = np.sum(den) img = Variable(img[None, :, :, :], volatile=True).cuda() # forward pred_map = net.test_forward(img) pred_map = pred_map.cpu().data.numpy()[0, 0, :, :] pred_cnt = np.sum(pred_map) / 2550.0 pred_map = pred_map / np.max(pred_map + 1e-20) pred_map = pred_map[0:ht_1, 0:wd_1] den = den / np.max(den + 1e-20) den = den[0:ht_1, 0:wd_1] maes.update(abs(gt_count - pred_cnt)) mses.update((gt_count - pred_cnt) * (gt_count - pred_cnt)) mae = maes.avg mse = np.sqrt(mses.avg) print '\n[MAE: %fms][MSE: %fms]' % (mae, mse)
def __init__(self, dataloader, cfg_data, pwd, cfg): self.cfg_data = cfg_data self.data_mode = cfg.DATASET self.exp_name = cfg.EXP_NAME self.exp_path = cfg.EXP_PATH self.pwd = pwd self.cfg = cfg self.net_name = cfg.NET self.net = CrowdCounter(cfg.GPU_ID, self.net_name).cuda() self.num_parameters = sum( [param.nelement() for param in self.net.parameters()]) print('num_parameters:', self.num_parameters) self.optimizer = optim.Adam(self.net.CCN.parameters(), lr=cfg.LR, weight_decay=1e-4) # self.optimizer = optim.SGD(self.net.parameters(), cfg.LR, momentum=0.95,weight_decay=5e-4) self.scheduler = StepLR(self.optimizer, step_size=cfg.NUM_EPOCH_LR_DECAY, gamma=cfg.LR_DECAY) self.train_record = { 'best_mae': 1e20, 'best_mse': 1e20, 'best_model_name': '_' } self.hparam = { 'lr': cfg.LR, 'n_epochs': cfg.MAX_EPOCH, 'number of parameters': self.num_parameters, 'dataset': cfg.DATASET } #,'finetuned':cfg.FINETUNE} self.timer = { 'iter time': Timer(), 'train time': Timer(), 'val time': Timer() } self.epoch = 0 self.i_tb = 0 if cfg.PRE_GCC: print('===================Loaded Pretrained GCC================') weight = torch.load(cfg.PRE_GCC_MODEL)['net'] # weight=torch.load(cfg.PRE_GCC_MODEL) try: self.net.load_state_dict(convert_state_dict_gcc(weight)) except: self.net.load_state_dict(weight) # self.net=torch.nn.DataParallel(self.net, device_ids=cfg.GPU_ID).cuda() self.train_loader, self.val_loader, self.restore_transform = dataloader( ) if cfg.RESUME: print('===================Loaded model to resume================') latest_state = torch.load(cfg.RESUME_PATH) self.net.load_state_dict(latest_state['net']) self.optimizer.load_state_dict(latest_state['optimizer']) self.scheduler.load_state_dict(latest_state['scheduler']) self.epoch = latest_state['epoch'] + 1 self.i_tb = latest_state['i_tb'] self.train_record = latest_state['train_record'] self.exp_path = latest_state['exp_path'] self.exp_name = latest_state['exp_name']
def test(file_list, model_path): net = CrowdCounter(cfg.GPU_ID, 'Res101_SFCN') net.cuda() lastest_state = torch.load(model_path) net.load_state_dict(lastest_state['net']) #net.load_state_dict(torch.load(model_path)) net.eval() #f = open('submmited.txt', 'w+') for infos in file_list: filename = infos.split()[0] #print(filename) imgname = os.path.join(dataRoot, 'img', filename + '.jpg') img = Image.open(imgname) dotname = imgname.replace('img', 'dot').replace('jpg', 'png') dot_map = Image.open(dotname) dot_map = dot_transform(dot_map) if img.mode == 'L': img = img.convert('RGB') img = img_transform(img)[None, :, :, :] dot_map = dot_map[None, :, :, :] with torch.no_grad(): img = Variable(img).cuda() dot_map = Variable(dot_map).cuda() algt = torch.sum(dot_map).item() crop_imgs, crop_dots, crop_masks = [], [], [] b, c, h, w = img.shape rh, rw = 576, 768 for i in range(0, h, rh): gis, gie = max(min(h-rh, i), 0), min(h, i+rh) for j in range(0, w, rw): gjs, gje = max(min(w-rw, j), 0), min(w, j+rw) crop_imgs.append(img[:, :, gis:gie, gjs:gje]) crop_dots.append(dot_map[:, :, gis:gie, gjs:gje]) mask = torch.zeros_like(dot_map).cuda() mask[:, :, gis:gie, gjs:gje].fill_(1.0) crop_masks.append(mask) crop_imgs, crop_dots, crop_masks = map(lambda x: torch.cat(x, dim=0), (crop_imgs, crop_dots, crop_masks)) # forward may need repeatng crop_preds, crop_dens = [], [] nz, bz = crop_imgs.size(0), 1 for i in range(0, nz, bz): gs, gt = i, min(nz, i+bz) crop_pred, crop_den = net.forward(crop_imgs[gs:gt], crop_dots[gs:gt]) crop_preds.append(crop_pred) crop_dens.append(crop_den) crop_preds = torch.cat(crop_preds, dim=0) crop_dens = torch.cat(crop_dens, dim=0) # splice them to the original size idx = 0 pred_map = torch.zeros_like(dot_map).cuda() den_map = torch.zeros_like(dot_map).cuda() for i in range(0, h, rh): gis, gie = max(min(h-rh, i), 0), min(h, i+rh) for j in range(0, w, rw): gjs, gje = max(min(w-rw, j), 0), min(w, j+rw) pred_map[:, :, gis:gie, gjs:gje] += crop_preds[idx] den_map[:, :, gis:gie, gjs:gje] += crop_dens[idx] idx += 1 # for the overlapping area, compute average value mask = crop_masks.sum(dim=0).unsqueeze(0) pred_map = pred_map / mask den_map = den_map / mask pred_map /= LOG_PARA pred = torch.sum(pred_map).item() pred_map = pred_map.cpu().data.numpy()[0,0,:,:] den_map = den_map.cpu().data.numpy()[0,0,:,:] print(pred_map.sum(), den_map.sum()) psnr = calc_psnr(den_map, pred_map) ssim = calc_ssim(den_map, pred_map) if psnr == 'NaN': plt.imsave(os.path.join('pred', f'[{filename}]_[{pred:.2f}|{algt:.2f}]_[{psnr}]_[{ssim:.4f}].png'), pred_map, cmap='jet') else: plt.imsave(os.path.join('pred', f'[{filename}]_[{pred:.2f}|{algt:.2f}]_[{psnr:.2f}]_[{ssim:.4f}].png'), pred_map, cmap='jet')
def validate(val_loader, model_path, epoch, restore): net = CrowdCounter(ce_weights=train_set.wts) net.load_state_dict(torch.load(model_path)) net.cuda() net.eval() print( '='*50 ) val_loss_mse = [] val_loss_cls = [] val_loss_seg = [] val_loss = [] mae = 0.0 mse = 0.0 for vi, data in enumerate(val_loader, 0): img, gt_map, gt_cnt, roi, gt_roi, gt_seg = data # pdb.set_trace() with torch.no_grad(): img = Variable(img).cuda() gt_map = Variable(gt_map).cuda() gt_seg = Variable(gt_seg).cuda() roi = Variable(roi[0]).cuda().float() gt_roi = Variable(gt_roi[0]).cuda() pred_map,pred_cls,pred_seg = net(img, gt_map, roi, gt_roi, gt_seg) loss1,loss2,loss3 = net.f_loss() val_loss_mse.append(loss1.item()) val_loss_cls.append(loss2.item()) val_loss_seg.append(loss3.item()) val_loss.append(net.loss.item()) pred_map = pred_map.data.cpu().numpy()/cfg.DATA.DEN_ENLARGE gt_map = gt_map.data.cpu().numpy()/cfg.DATA.DEN_ENLARGE pred_seg = pred_seg.cpu().max(1)[1].squeeze_(1).data.numpy() gt_seg = gt_seg.data.cpu().numpy() gt_count = np.sum(gt_map) pred_cnt = np.sum(pred_map) mae += abs(gt_count-pred_cnt) mse += ((gt_count-pred_cnt)*(gt_count-pred_cnt)) x = [] if vi==0: for idx, tensor in enumerate(zip(img.cpu().data, pred_map, gt_map, pred_seg, gt_seg)): if idx>cfg.VIS.VISIBLE_NUM_IMGS: break # pdb.set_trace() pil_input = restore(tensor[0]/255.) pil_label = torch.from_numpy(tensor[2]/(tensor[2].max()+1e-10)).repeat(3,1,1) pil_output = torch.from_numpy(tensor[1]/(tensor[1].max()+1e-10)).repeat(3,1,1) pil_gt_seg = torch.from_numpy(tensor[4]).repeat(3,1,1).float() pil_pred_seg = torch.from_numpy(tensor[3]).repeat(3,1,1).float() # pdb.set_trace() x.extend([pil_to_tensor(pil_input.convert('RGB')), pil_label, pil_output, pil_gt_seg, pil_pred_seg]) x = torch.stack(x, 0) x = vutils.make_grid(x, nrow=5, padding=5) writer.add_image(exp_name + '_epoch_' + str(epoch+1), (x.numpy()*255).astype(np.uint8)) mae = mae/val_set.get_num_samples() mse = np.sqrt(mse/val_set.get_num_samples()) ''' loss1 = float(np.mean(np.array(val_loss_mse))) loss2 = float(np.mean(np.array(val_loss_cls))) loss3 = float(np.mean(np.array(val_loss_seg))) loss = float(np.mean(np.array(val_loss)))''' loss1 = np.mean(val_loss_mse) loss2 = np.mean(val_loss_cls) loss3 = np.mean(val_loss_seg) loss = np.mean(val_loss) writer.add_scalar('val_loss_mse', loss1, epoch + 1) writer.add_scalar('val_loss_cls', loss2, epoch + 1) writer.add_scalar('val_loss_seg', loss3, epoch + 1) writer.add_scalar('val_loss', loss, epoch + 1) writer.add_scalar('mae', mae, epoch + 1) writer.add_scalar('mse', mse, epoch + 1) if mae < train_record['best_mae']: train_record['best_mae'] = mae train_record['mse'] = mse train_record['corr_epoch'] = epoch + 1 train_record['corr_loss'] = loss print( '='*50 ) print( exp_name ) print( ' '+ '-'*20 ) print( ' [mae %.1f mse %.1f], [val loss %.8f %.8f %.4f %.4f]' % (mae, mse, loss, loss1, loss2, loss3) ) print( ' '+ '-'*20 ) # pdb.set_trace() print( '[best] [mae %.1f mse %.1f], [loss %.8f], [epoch %d]' % (train_record['best_mae'], train_record['mse'], train_record['corr_loss'], train_record['corr_epoch']) ) print( '='*50 )