def get_item(self, index, shift=None): ims, tars, meta = [], [], {} meta['do_not_collate'] = True fps = 24 n = self.data['datas'][index]['n'] if shift is None: shift = np.random.randint(n - self.train_gap - 2) else: shift = int(shift * (n - self.train_gap - 2)) resize = transforms.Resize(int(256. / 224 * self.input_size)) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) spacing = np.arange(shift, shift + self.train_gap) for loc in spacing: ii = int(np.floor(loc)) path = '{}{:06d}.jpg'.format(self.data['datas'][index]['base'], ii + 1) try: # ============ Temp =================== timer = Timer() img = default_loader(path) # ============ Temp =================== load_img_cost = timer.thetime() - timer.end timer.tic() print( 'Load image from disk: {0:.3f} sec'.format(load_img_cost)) except Exception as e: print('failed to load image {}'.format(path)) print(e) raise img = resize(img) img = transforms.ToTensor()(img) # ============ Temp =================== # totensor_cost = timer.thetime() - timer.end # timer.tic() # print('From PIL to tensor: {0:.3f} sec'.format(totensor_cost)) #img = 2*img - 1 img = normalize(img) ims.append(img) target = torch.IntTensor(self.num_classes).zero_() for x in self.data['datas'][index]['labels']: if x['start'] < ii / float(fps) < x['end']: target[self.cls2int(x['class'])] = 1 tars.append(target) meta['id'] = self.data['datas'][index]['id'] meta['time'] = shift img = torch.stack(ims).permute(0, 2, 3, 1).numpy() target = torch.stack(tars) if self.transform is not None: img = self.transform(img) # ============ Temp =================== # transform_cost = timer.thetime() - timer.end # timer.tic() # print('Image transform per mini-batch: {0:.3f} sec'.format(transform_cost)) if self.target_transform is not None: target = self.target_transform(target) # batch will be b x n x h x w x c # target will be b x n x nc return img, target, meta
def train(loader, model, optimizer, epoch, args): timer = Timer() data_time = AverageMeter() loss_meter = AverageMeter() ce_loss_meter = AverageMeter() cur_lr = adjust_learning_rate(args.lr_decay_rate, optimizer, epoch) model.train() optimizer.zero_grad() ce_loss_criterion = nn.CrossEntropyLoss() for i, (input, meta) in tqdm(enumerate(loader), desc="Train Epoch"): if args.debug and i >= debug_short_train_num: break data_time.update(timer.thetime() - timer.end) _batch_size = len(meta) target = [] for _ in range(_batch_size): target.extend(meta[_]["labels"]) target = torch.from_numpy(np.array(target)) input = input.view( _batch_size * 3, input.shape[2], input.shape[3], input.shape[4], input.shape[5], ) metric_feat, output = model(input) ce_loss = ce_loss_criterion(output.cuda(), target.long().cuda()) loss = ce_loss loss.backward() loss_meter.update(loss.item()) ce_loss_meter.update(ce_loss.item()) if i % args.accum_grad == args.accum_grad - 1: optimizer.step() optimizer.zero_grad() if i % args.print_freq == 0 and i > 0: logger.info("[{0}][{1}/{2}]\t" "Dataload_Time={data_time.avg:.3f}\t" "Loss={loss.avg:.4f}\t" "CELoss={ce_loss.avg:.4f}\t" "LR={cur_lr:.7f}\t" "bestAP={ap:.3f}".format( epoch, i, len(loader), data_time=data_time, loss=loss_meter, ce_loss=ce_loss_meter, ap=args.best_score, cur_lr=cur_lr, )) loss_meter.reset() ce_loss_meter.reset()
def read_multi_images(target_dir): timer = Timer() image_num = 0 for f in listdir(target_dir): file_full_path = join(target_dir, f) if isfile(file_full_path): read_one_iamge(file_full_path) image_num += 1 time_cost = timer.thetime() - timer.end print('Load images from disk: {0:.3f} sec'.format(time_cost)) return time_cost, image_num
def train(self, loader, model, criterion, optimizer, epoch, metrics, args, validate=False): timer = Timer() data_time = AverageMeter() losses = AverageMeter() metrics = [m() for m in metrics] if validate: # switch to evaluate mode model.eval() criterion.eval() iter_size = args.val_size setting = 'Validate Epoch' else: # switch to train mode adjust_learning_rate(args.lr, args.lr_decay_rate, optimizer, epoch) model.train() criterion.train() optimizer.zero_grad() iter_size = args.train_size setting = 'Train Epoch' for i, (input, target, meta) in enumerate(part(loader, iter_size)): if args.synchronous: assert meta['id'][0] == meta['id'][1], "dataset not synced" data_time.update(timer.thetime() - timer.end) if not args.cpu: target = target.cuda(non_blocking=True) output = model(input, meta) if type(output) != tuple: output = (output,) scores, loss, score_target = criterion(*(output + (target, meta))) losses.update(loss.item()) with torch.no_grad(): for m in metrics: m.update(scores, score_target) if not validate: loss.backward() if i % args.accum_grad == args.accum_grad-1: print('updating parameters') optimizer.step() optimizer.zero_grad() timer.tic() if i % args.print_freq == 0: print('[{name}] {setting}: [{0}][{1}/{2}({3})]\t' 'Time {timer.val:.3f} ({timer.avg:.3f})\t' 'Data {data_time.val:.3f} ({data_time.avg:.3f})\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' '{metrics}'.format( epoch, i, int(len(loader)*iter_size), len(loader), name=args.name, setting=setting, timer=timer, data_time=data_time, loss=losses, metrics=' \t'.join(str(m) for m in metrics))) del loss, output, target # make sure we don't hold on to the graph metrics = dict(m.compute() for m in metrics) metrics.update({'loss': losses.avg}) metrics = dict(('val_'+k, v) if validate else ('train_'+k, v) for k, v in metrics.items()) return metrics
""" Video loader for the Charades dataset """ from datasets import utils from misc_utils.utils import Timer # path = '/home/SERILOCAL/xiatian.zhu/Data/test_video/ZZXQF-000002.jpg' path = '/home/nfs/x.chang/Datasets/Charades/Charades/Charades_v1_rgb/ZZXQF/ZZXQF-000002.jpg' for i in range(10): try: # ============ Temp =================== timer = Timer() img = utils.default_loader(path) # ============ Temp =================== load_img_cost = timer.thetime() - timer.end timer.tic() print('Load image from disk: {0:.3f} sec'.format(load_img_cost)) except Exception as e: print('failed to load image {}'.format(path)) print(e) raise