def main(): cfg_file = open('./config.py',"r") cfg_lines = cfg_file.readlines() with open(log_txt, 'a') as f: f.write(''.join(cfg_lines) + '\n\n\n\n') torch.cuda.set_device(cfg.TRAIN.GPU_ID[0]) torch.backends.cudnn.benchmark = True net = CrowdCounter(ce_weights=train_set.wts) net.train() optimizer = optim.Adam([ {'params': [param for name, param in net.named_parameters() if 'seg' in name], 'lr': cfg.TRAIN.SEG_LR}, {'params': [param for name, param in net.named_parameters() if 'seg' not in name], 'lr': cfg.TRAIN.LR} ]) i_tb = 0 for epoch in range(cfg.TRAIN.MAX_EPOCH): _t['train time'].tic() i_tb,model_path = train(train_loader, net, optimizer, epoch, i_tb) _t['train time'].toc(average=False) print( 'train time of one epoch: {:.2f}s'.format(_t['train time'].diff) ) if epoch%cfg.VAL.FREQ!=0: continue _t['val time'].tic() validate(val_loader, model_path, epoch, restore_transform) _t['val time'].toc(average=False) print( 'val time of one epoch: {:.2f}s'.format(_t['val time'].diff))
def __init__(self, dataloader, cfg_data, pwd): self.save_path = os.path.join('/mnt/home/dongsheng/hudi/counting/trained_models/img-den-mel-pred', str(cfg.NET) + '-' + 'noise-' + str(cfg_data.IS_NOISE) + '-' + str( cfg_data.BRIGHTNESS) + '-' + str(cfg_data.NOISE_SIGMA) + '-' + str(cfg_data.LONGEST_SIDE) + '-' + str( cfg_data.BLACK_AREA_RATIO) + '-' + str(cfg_data.IS_RANDOM) + '-' + 'denoise-' + str(cfg_data.IS_DENOISE)) if not os.path.exists(self.save_path): os.system('mkdir ' + self.save_path) else: os.system('rm -rf ' + self.save_path) os.system('mkdir ' + self.save_path) self.cfg_data = cfg_data self.cfg = cfg self.data_mode = cfg.DATASET self.exp_name = cfg.EXP_NAME self.exp_path = cfg.EXP_PATH self.pwd = pwd self.net_name = cfg.NET self.net = CrowdCounter(cfg.GPU_ID, self.net_name).cuda() self.optimizer = optim.Adam(self.net.CCN.parameters(), lr=cfg.LR, weight_decay=1e-4) # self.optimizer = optim.SGD(self.net.CCN.parameters(), cfg.LR, momentum=0.9, 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.timer = {'iter time': Timer(), 'train time': Timer(), 'val time': Timer()} self.epoch = 0 self.i_tb = 0 if cfg.PRE_GCC: self.net.load_state_dict(torch.load(cfg.PRE_GCC_MODEL)) self.train_loader, self.val_loader, self.test_loader, self.restore_transform = dataloader() if cfg.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'] latest_state = torch.load(cfg.RESUME_PATH) try: self.net.load_state_dict(latest_state) except: self.net.load_state_dict({k.replace('module.', ''): v for k, v in latest_state.items()})
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'] self.writer, self.log_txt = logger(self.exp_path, self.exp_name, self.pwd, 'exp',self.train_loader, self.val_loader, resume=cfg.RESUME,cfg=cfg)
def __init__(self, dataloader, cfg_data, pwd): 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.net_name = cfg.NET self.net = CrowdCounter(cfg.GPU_ID, self.net_name).cuda() print(self.net) print('Use model: {}'.format(cfg.NET)) 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.timer = { 'iter time': Timer(), 'train time': Timer(), 'val time': Timer() } self.writer, self.log_txt = logger(self.exp_path, self.exp_name, self.pwd, 'exp') self.i_tb = 0 self.epoch = -1 if cfg.PRE_GCC: self.net.load_state_dict(torch.load(cfg.PRE_GCC_MODEL)) self.train_loader, self.val_loader, self.restore_transform = dataloader( )
def main(params): H, W = params['image_size'] mean_std = ([0.452016860247, 0.447249650955, 0.431981861591], [0.23242045939, 0.224925786257, 0.221840232611]) data_transform = transforms.Compose([ transforms.Resize((H, W)), transforms.ToTensor(), transforms.Normalize(*mean_std) ]) net = CrowdCounter([0], params['model']) net.load_state_dict(torch.load(params['model_path'])) net.cuda() net.eval() video_list = np.sort(glob(params['dataset_path'] + '/*')) for v in video_list: print(v) outputdir = params['outputdir_prefix'] + '/%d_%d/' % (H, W) os.makedirs(outputdir, exist_ok=True) file_list = np.sort(glob(v + '/*.jpg')) imgs = torch.zeros(len(file_list), 3, H, W) for i, f in enumerate(tqdm(file_list)): imgs[i] = data_transform(Image.open(f)) train_dataset = torch.utils.data.TensorDataset( imgs, torch.zeros(len(file_list))) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=params['batch_size'], shuffle=False) pred_map = [] for x, y in tqdm(train_loader): tmp = net.test_forward(x.cuda()).squeeze().detach().cpu().numpy() if (len(tmp.shape) == 2): tmp = tmp[np.newaxis] pred_map.append(tmp) pred_map = np.concatenate(pred_map) np.savez_compressed(outputdir + os.path.basename(v), pred_map)
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 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()
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 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))
class Trainer(): def __init__(self, cfg_data, pwd): self.cfg_data = cfg_data self.train_loader, self.val_loader, self.restore_transform = datasets.loading_data( cfg.DATASET) self.data_mode = cfg.DATASET self.exp_name = cfg.EXP_NAME self.exp_path = cfg.EXP_PATH self.pwd = pwd self.net_name = cfg.NET self.net = CrowdCounter(cfg.GPU_ID, self.net_name).cuda() 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_bce_loss': 1e20, 'best_model_name': ''} self.timer = { 'iter time': Timer(), 'train time': Timer(), 'val time': Timer() } self.epoch = 0 self.i_tb = 0 if cfg.PRE_GCC: self.net.load_state_dict(torch.load(cfg.PRE_GCC_MODEL)) if cfg.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', resume=cfg.RESUME) def forward(self): self.validate() for epoch in range(self.epoch, cfg.MAX_EPOCH): self.epoch = epoch # training self.timer['train time'].tic() self.train() self.timer['train time'].toc(average=False) print('train time: {:.2f}s'.format(self.timer['train time'].diff)) print('=' * 20) # validation if epoch % cfg.VAL_FREQ == 0 or epoch > cfg.VAL_DENSE_START: self.timer['val time'].tic() self.validate() self.timer['val time'].toc(average=False) print('val time: {:.2f}s'.format(self.timer['val time'].diff)) if epoch > cfg.LR_DECAY_START: self.scheduler.step() def train(self): # training for all datasets self.net.train() for i, data in enumerate(self.train_loader, 0): self.timer['iter time'].tic() img, gt_map = data img = Variable(img).cuda() gt_map = Variable(gt_map).cuda() self.optimizer.zero_grad() pred_map, _ = self.net(img, gt_map) loss = self.net.loss loss.backward() self.optimizer.step() if (i + 1) % cfg.PRINT_FREQ == 0: self.i_tb += 1 self.writer.add_scalar('train_loss', loss.item(), self.i_tb) self.timer['iter time'].toc(average=False) print( '[ep %d][it %d][loss %.4f][lr %.4f][%.2fs]' % \ (self.epoch + 1, i + 1, loss.item(), self.optimizer.param_groups[0]['lr']*10000, self.timer['iter time'].diff) ) def validate(self): self.net.eval() losses = AverageMeter() for vi, data in enumerate(self.val_loader, 0): img, dot_map, attributes_pt = data with torch.no_grad(): img = Variable(img).cuda() dot_map = Variable(dot_map).cuda() pred_map, loc_gt_map = self.net.forward(img, dot_map) pred_map = F.softmax(pred_map, dim=1).data.max(1) pred_map = pred_map[1].squeeze_(1) # # crop the img and gt_map with a max stride on x and y axis # # size: HW: __C_NWPU.TRAIN_SIZE # # stack them with a the batchsize: __C_NWPU.TRAIN_BATCH_SIZE # crop_imgs, crop_dots, crop_masks = [], [], [] # b, c, h, w = img.shape # rh, rw = self.cfg_data.TRAIN_SIZE # 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_loc_gts = [], [] # nz, bz = crop_imgs.size(0), self.cfg_data.TRAIN_BATCH_SIZE # for i in range(0, nz, bz): # gs, gt = i, min(nz, i+bz) # #pdb.set_trace() # # print(crop_imgs[gs:gt].shape) # # print(crop_dots[gs:gt].shape) # crop_pred, crop_loc_gt = self.net.forward(crop_imgs[gs:gt], crop_dots[gs:gt]) # crop_pred = F.softmax(crop_pred,dim=1).data.max(1) # crop_pred = crop_pred[1].squeeze_(1) # crop_preds.append(crop_pred) # crop_loc_gts.append(crop_loc_gt) # crop_preds = torch.cat(crop_preds, dim=0) # crop_loc_gts = torch.cat(crop_loc_gts, dim=0) # # splice them to the original size # idx = 0 # pred_map = torch.zeros_like(dot_map).cuda() # loc_gt_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] # loc_gt_map[:, :, gis:gie, gjs:gje] += crop_loc_gts[idx] # idx += 1 # # for the overlapping area, compute average value # mask = crop_masks.sum(dim=0).unsqueeze(0) # pred_map = (pred_map / mask).bool().long() # loc_gt_map = (loc_gt_map / mask).bool().long() pred_map = pred_map.bool().long() loc_gt_map = loc_gt_map.bool().long() # pdb.set_trace() pred_map = pred_map.data.cpu().numpy() loc_gt_map = loc_gt_map.data.cpu().numpy() losses.update(self.net.loss.item()) if vi == 0: vis_results(self.exp_name, self.epoch, self.writer, self.restore_transform, img, pred_map, loc_gt_map) loss = losses.avg self.writer.add_scalar('val_loss', loss, self.epoch + 1) self.train_record = update_model(self.net,self.optimizer,self.scheduler,self.epoch,self.i_tb,self.exp_path,self.exp_name, \ loss,self.train_record,self.log_txt) print_NWPU_summary(self.exp_name, self.log_txt, self.epoch, loss, self.train_record)
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)