def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Device being used:", device) with open('./dataloaders/aps_labels.txt', 'r') as f: class_names = f.readlines() f.close() model = C3D_model.C3D(num_classes=24) checkpoint = torch.load(weight, map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) model.to(device) model.eval() cap = cv2.VideoCapture(video) retaining = True wait = False clip = [] while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, (171, 128))) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable(inputs, requires_grad=False).to(device) with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] probs = probs[0][label] name = class_names[label].split(' ')[-1].strip() cv2.putText(frame, name, (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1) cv2.putText(frame, "prob: %.4f" % probs, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1) clip.pop(0) if wait == True and probs < 0.4: wait = False if wait == False and probs > 0.9: print(name) wait = True cv2.imshow('result', frame) cv2.waitKey(30) cap.release() cv2.destroyAllWindows()
def setup(ckpt_path: str) -> nn.Module: '''配置模型的GPU/CPU环境 Args: ckpt_path(str): 模型检查点路径 Return: model(nn.Module): 配置好的模型 device(torch.device): 模型可用的环境 ''' model = C3D_model.C3D(num_classes=2) use_cuda = torch.cuda.is_available() device_name = 'cuda:0' if use_cuda else 'cpu' device = torch.device(device_name) params = {} if use_cuda else {'map_location': 'cpu'} # 恢复检查点 if ckpt_path is not None: assert os.path.exists(ckpt_path), '无效的路径{}'.format(ckpt_path) ckpt = torch.load(ckpt_path, **params) model.load_state_dict(ckpt['state_dict']) model.to(device) model.eval() return model, device
def predict_c3d(video): # device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # print("Device being used:", device) with open('./dataloaders/ucf_labels.txt', 'r') as f: class_names = f.readlines() f.close() # init model model = C3D_model.C3D(num_classes=101) checkpoint = torch.load('run/run_3/models/C3D-ucf101_epoch-99.pth', map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) # model.to(device) model.eval() # read video # video = '/Path/to/UCF-101/ApplyLipstick/v_ApplyLipstick_g04_c02.avi' cap = cv2.VideoCapture(video) retaining = True clip = [] while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, (171, 128))) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable(inputs, requires_grad=False) # .to(device) with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] prob = "%.4f" % probs[0][label] Label = class_names[label].split(' ')[-1].strip() # cv2.putText(frame, class_names[label].split(' ')[-1].strip(), (20, 20), # cv2.FONT_HERSHEY_SIMPLEX, 0.6, # (0, 0, 255), 1) # cv2.putText(frame, "prob: %.4f" % probs[0][label], (20, 40), # cv2.FONT_HERSHEY_SIMPLEX, 0.6, # (0, 0, 255), 1) # clip.pop(0) # # cv2.imshow('result', frame) # cv2.waitKey(30) # # cap.release() # cv2.destroyAllWindows() return Label, prob
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Device being used:", device) with open('./dataloaders/ucf_labels.txt', 'r') as f: class_names = f.readlines() f.close() # init model model = C3D_model.C3D(num_classes=101) checkpoint = torch.load('run/run_10/models/C3D-ucf101_epoch-99.pth.tar', map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) model.to(device) model.train() # read video video = '/data/Sadjad/Datasets/ucf101/v_WritingOnBoard_g03_c03.avi' # '/data/Sadjad/Datasets/DALY/download_videos/videos/3\ WAYS\ OF\ APPLYING\ RED\ LIPSTICK\ l\ Pearltji-YCqSlzeFvn4.mp4' # '/data/Sadjad/Datasets/ucf101/UCF-101/StillRings/v_StillRings_g04_c02.avi' cap = cv2.VideoCapture(0) # video) # retaining = True clip = [] while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, (171, 128))) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable(inputs, requires_grad=False).to(device) with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] cv2.putText(frame, class_names[label].split(' ')[-1].strip(), (20, 50), cv2.FONT_HERSHEY_SIMPLEX, 2.0, (0, 0, 255), 1) cv2.putText(frame, "prob: %.4f" % probs[0][label], (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1) clip.pop(0) cv2.imshow('result', frame) cv2.waitKey(30) cap.release() cv2.destroyAllWindows()
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Device being used:", device) with open('./dataloaders/ucf_labels.txt', 'r') as f: class_names = f.readlines() f.close() # init model model = C3D_model.C3D(num_classes=2) checkpoint = torch.load( '/home/zhouzhilong/pytorch-video-recognition/run/run_5/models/C3D-ucf101_epoch-199.pth.tar', map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) model.to(device) model.eval() # read video video = '/hhd12306/zhouzhilong/UCF-101/ApplyEyeMakeup/v_ApplyEyeMakeup_g01_c01.avi' cap = cv2.VideoCapture(video) retaining = True clip = [] print(cap.isOpened()) while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, (171, 128))) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable(inputs, requires_grad=False).to(device) with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] cv2.putText(frame, class_names[label].split(' ')[-1].strip(), (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1) cv2.putText(frame, "prob: %.4f" % probs[0][label], (40, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1) clip.pop(0) print(class_names[label].split(' ')[-1].strip()) cv2.imshow('result', frame) cv2.waitKey(30) cap.release() cv2.destroyAllWindows()
def _pre_model(self): ''' Prepare the model ''' model, train_params = None, None if self.model_name == 'C3D': model = C3D_model.C3D(num_classes=self.num_classes, pretrained=self.pretrained) train_params = [{'params': C3D_model.get_1x_lr_params(model), 'lr': self.lr}, {'params': C3D_model.get_10x_lr_params(model), 'lr': self.lr * 10}] else: raise TypeError('Unknown model name ...') model.to(self.device) criterion = nn.CrossEntropyLoss().to(self.device) optimizer = optim.SGD(train_params, lr=self.lr, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) if self.resume_epoch == 0: print("Training {} from scratch...".format(self.model_name)) else: resume_file = PathSet.model_dir(model_name = self.model_name, cur_epochs =self.resume_epoch) checkpoint = torch.load(resume_file, map_location=lambda storage, loc: storage) print("Initializing weights from: {}...".format(resume_file.split('/')[-1])) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['opt_dict']) print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) #model.to(self.device); criterion.to(self.device) model_cache = (model, criterion, optimizer, scheduler) return model_cache
def test_model(dataset=dataset, save_dir=save_dir, num_classes=num_classes, num_epochs=nEpochs): torch.cuda.empty_cache() model = C3D_model.C3D(num_classes=num_classes, pretrained=False) model.load_state_dict(torch.load(os.path.listdir(save_dir)[-1])) params = model.parameters() criterion = nn.CrossEntropyLoss() test_dataloader = DataLoader(VideoDataset(dataset=dataset, split='test', clip_len=16), batch_size=batch_size, num_workers=num_workers) test_size = len(test_dataloader.dataset) model.to(device) criterion.to(device) #print(model) model.eval() start_time = timeit.default_timer() running_loss = 0.0 running_corrects = 0.0 for inputs, labels in tqdm(test_dataloader): inputs = inputs.to(device) labels = labels.to(device) with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels) running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) loss = running_loss / test_size acc = running_corrects.double() / test_size print("[test] Loss: {} Acc: {}".format(loss, acc) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") if __name__ == "__main__": test_model()
def main(): device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") #use the second gpu print("Device being used:", device) with open('actions_labels.txt', 'r') as f: class_names = f.readlines() f.close() #print(class_names) # init model model = C3D_model.C3D(num_classes=48) model = nn.DataParallel(model) checkpoint = torch.load('C3D39.pth.tar', map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) model.to(device) model.eval() # read video video = 'P08_tea.avi' cap = cv2.VideoCapture(video) retaining = True clip = [] while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, (171, 128))) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable(inputs, requires_grad=False).to(device) with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) top5probs, labels = torch.topk(probs, 5) #action 1 shown cv2.putText(frame, class_names[labels[0][0]].split(' ')[-1].strip(), (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 5), 1, cv2.LINE_AA) cv2.putText(frame, "prob: %.4f" % top5probs[0][0], (110, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (30, 30, 255), 1, cv2.LINE_AA) #action 2 shown cv2.putText(frame, class_names[labels[0][1]].split(' ')[-1].strip(), (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 5), 1, cv2.LINE_AA) cv2.putText(frame, "prob: %.4f" % top5probs[0][1], (110, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (30, 30, 255), 1, cv2.LINE_AA) #action 3 shown cv2.putText(frame, class_names[labels[0][2]].split(' ')[-1].strip(), (20, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 5), 1, cv2.LINE_AA) cv2.putText(frame, "prob: %.4f" % top5probs[0][2], (110, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (30, 30, 255), 1, cv2.LINE_AA) #action 4 shown cv2.putText(frame, class_names[labels[0][3]].split(' ')[-1].strip(), (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 5), 1, cv2.LINE_AA) cv2.putText(frame, "prob: %.4f" % top5probs[0][3], (110, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (30, 30, 255), 1, cv2.LINE_AA) #action 5 shown cv2.putText(frame, class_names[labels[0][4]].split(' ')[-1].strip(), (20, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 5), 1, cv2.LINE_AA) cv2.putText(frame, "prob: %.4f" % top5probs[0][4], (110, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (30, 30, 255), 1, cv2.LINE_AA) clip.pop(0) cv2.imshow('result', frame) cv2.waitKey(30) cap.release() cv2.destroyAllWindows()
def start(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Device being used:", device) nEpochs = 101 # 训练集epoch resume_epoch = 0 # 是否从头开始训练,0表示从头,如果是99,表示从99次训练之后的模型开始训练 useTest = True # 训练的时候是否看下训练集的效果 nTestInterval = 20 # 训练集的epoch snapshot = 25 # 训练多少个epoch之后保存 lr = 1e-5 # Learning rate dataset = "ucf101" num_classes = 101 # 获取当前路径和文件所属的目录 save_dir_root = os.path.join(os.path.dirname(os.path.abspath(__file__))) # videoprocess exp_name = os.path.dirname(os.path.abspath(__file__)).split('/')[-1] # 如果是要从之前的model开始训练,拿到最后一次run的id,如果从头开始,最后一次的id再加1 # glob.glob()函数的作用:将拼接的符合的文件或者文件夹名字全部读取 if resume_epoch != 0: runs = sorted(glob.glob(os.path.join(save_dir_root, 'run', 'run_*'))) run_id = int(runs[-1].split('_')[-1]) if runs else 0 else: runs = sorted(glob.glob(os.path.join(save_dir_root, 'run', 'run_*'))) run_id = int(runs[-1].split('_')[-1]) + 1 if runs else 0 save_dir = os.path.join(save_dir_root, 'run', 'run_' + str(run_id)) modelName = 'C3D' saveName = modelName + '-' + dataset # 创建模型 model = C3D_model.C3D(num_classes=num_classes, pretrained=False) train_params = [{'params': C3D_model.get_1x_lr_params(model), 'lr': lr}, {'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10}] criterion = nn.CrossEntropyLoss() # 交叉熵损失函数 optimizer = optim.SGD(train_params, lr=lr, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) if resume_epoch == 0: print("Training {} from scratch...".format(modelName)) else: checkpoint = torch.load( os.path.join(save_dir, 'models', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'), map_location=lambda storage, loc: storage) # Load all tensors onto the CPU print("Initializing weights from: {}...".format( os.path.join(save_dir, 'models', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'))) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['opt_dict']) # 查看网络的参数个数 print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) model.to(device) criterion.to(device) log_dir = os.path.join(save_dir, 'models', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname()) writer = SummaryWriter(log_dir=log_dir) print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train', clip_len=16), batch_size=6, shuffle=True, num_workers=0) val_dataloader = DataLoader(VideoDataset(dataset=dataset, split='val', clip_len=16), batch_size=6, num_workers=0) test_dataloader = DataLoader(VideoDataset(dataset=dataset, split='test', clip_len=16), batch_size=6, num_workers=0) trainval_loaders = {'train': train_dataloader, 'val': val_dataloader} trainval_sizes = {x: len(trainval_loaders[x].dataset) for x in ['train', 'val']} test_size = len(test_dataloader.dataset) for epoch in range(resume_epoch, nEpochs): # each epoch has a training and validation step for phase in ['train', 'val']: start_time = timeit.default_timer() # reset the running loss and corrects running_loss = 0.0 running_corrects = 0.0 # set model to train() or eval() mode depending on whether it is trained # or being validated. Primarily affects layers such as BatchNorm or Dropout. if phase == 'train': # scheduler.step() is to be called once every epoch during training scheduler.step() model.train() else: model.eval() # tqdm可以展示训练的进度条 for inputs, labels in tqdm(trainval_loaders[phase]): # move inputs and labels to the device the training is taking place on inputs = torch.tensor(inputs, requires_grad=True).to(device) labels = torch.tensor(labels).to(device) optimizer.zero_grad() if phase == 'train': outputs = model(inputs) else: with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels.long()) if phase == 'train': loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / trainval_sizes[phase] epoch_acc = running_corrects.double() / trainval_sizes[phase] if phase == 'train': writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch) else: writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch) print("[{}] Epoch: {}/{} Loss: {} Acc: {}".format(phase, epoch+1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") if epoch % snapshot == (snapshot - 1): torch.save({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'opt_dict': optimizer.state_dict(), }, os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar')) print("Save model at {}\n".format(os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar'))) if useTest and epoch % nTestInterval == (nTestInterval - 1): model.eval() start_time = timeit.default_timer() running_loss = 0.0 running_corrects = 0.0 for inputs, labels in tqdm(test_dataloader): inputs = inputs.to(device) labels = labels.to(device) with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels.long()) running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / test_size epoch_acc = running_corrects.double() / test_size writer.add_scalar('data/test_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/test_acc_epoch', epoch_acc, epoch) print("[test] Epoch: {}/{} Loss: {} Acc: {}".format(epoch+1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") writer.close()
def gif_generator(self): ''' Generate a demo for show step - 1. prepare the target video step - 2. load the arrchitecture and epoch_model step - 3. start inference ''' # step - 1 class_list, class_name, video_name = self._get_videoinfo() video_path = os.path.join(PathSet.root_dir(), 'dataset/ucf101_related/UCF-101', class_name, video_name + '.avi') video = cv2.VideoCapture(video_path) # step - 2 model = C3D_model.C3D(num_classes=101).to(self.device) model_path = PathSet.model_dir('C3D', self.epoch_id) checkpoint = torch.load(model_path, map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) model.eval() # step - 3 retaining, clip, text_imglist = True, [], [] while retaining: retaining, frame = video.read() if not retaining and frame is None: continue tmp_ = self.center_crop(cv2.resize(frame, (171, 128)), size=(112, 112)) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) # normalize clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable( inputs, requires_grad=False).to(self.device) with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] cv2.putText(frame, class_list[label].split(' ')[-1].strip(), (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1) cv2.putText(frame, "prob: %.4f" % probs[0][label], (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 1) text_imglist.append(frame) clip.pop(0) # cv2.imshow('test video', frame) # cv2.waitKey(2) gif_path = os.path.join(PathSet.root_dir(), 'model_demo/C3D/', class_name + video_name + '.gif') imageio.mimsave(gif_path, text_imglist, fps=12) video.release()
def main(): print ("device is available : ", torch.cuda.is_available()) with open("./dataloaders/ucf_labels.txt", 'r') as f: class_names = f.readlines() f.close() # input model model = C3D_model.C3D(num_classes = 101) # 加载模型 checkpoint = torch.load( './run/run_0/models/C3D-ucf101_epoch-99.pth.tar', map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) model.cuda() model.eval() video = './CliffDiving.mp4' cap = cv2.VideoCapture(video) retaining = True # 该参数是MPEG-4编码类型,后缀名为avi fourcc = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter('Output_CliffDiving.avi', fourcc, 20.0, (320, 240)) clip = [] while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, (171, 128))) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = inputs.cuda() with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] cv2.putText(frame, class_names[label].split(' ')[-1].strip(), (10, 205), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (138, 43, 226), 2) cv2.putText(frame, "Prob: %.4f" % probs[0][label], (10, 230), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (138, 43, 226), 2) clip.pop(0) if retaining == True: # write the flipped frame out.write(frame) cv2.imshow('frame', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break else: break cap.release() out.release() cv2.destroyAllWindows()
def train_model(dataset=dataset, save_dir=save_dir, num_classes=num_classes, lr=lr, num_epochs=nEpochs, save_epoch=snapshot): torch.cuda.empty_cache() ##model = C3D_model.C3D_Dilation(num_classes=num_classes, pretrained=False) model = C3D_model.C3D(num_classes=num_classes, pretrained=False) train_params = model.parameters() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(train_params, lr=lr, momentum=0.9, weight_decay=5e-4) #scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) print("Training {} from scratch...".format(modelName)) print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) model.to(device) criterion.to(device) #print(model) log_dir = os.path.join( save_dir, 'models', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname()) writer = SummaryWriter(log_dir=log_dir) print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train', clip_len=16), batch_size=batch_size, shuffle=True, num_workers=num_workers) val_dataloader = DataLoader(VideoDataset(dataset=dataset, split='val', clip_len=16), batch_size=batch_size, num_workers=num_workers) trainval_loaders = {'train': train_dataloader, 'val': val_dataloader} trainval_sizes = { x: len(trainval_loaders[x].dataset) for x in ['train', 'val'] } for epoch in range(num_epochs): for phase in ['train', 'val']: confusion_matrix = torch.zeros(num_classes, num_classes) start_time = timeit.default_timer() running_loss = 0.0 running_corrects = 0.0 if phase == 'train': model.train() #scheduler.step() else: model.eval() for inputs, labels in tqdm(trainval_loaders[phase]): inputs = Variable(inputs, requires_grad=True).to(device) labels = Variable(labels).to(device=device, dtype=torch.int64) optimizer.zero_grad() if phase == 'train': outputs = model(inputs) else: with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels) if phase == 'train': loss.backward() optimizer.step() for t, p in zip(labels.view(-1), preds.view(-1)): confusion_matrix[t.long(), p.long()] += 1 running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / trainval_sizes[phase] epoch_acc = running_corrects.double() / trainval_sizes[phase] if phase == 'train': writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch) else: writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch) print("[{}] Epoch: {}/{} Loss: {} Acc: {}".format( phase, epoch + 1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") print(confusion_matrix.diag() / confusion_matrix.sum(1)) if epoch % save_epoch == (save_epoch - 1): PATH = os.path.join( save_dir, saveName + '_epoch-' + str(epoch + 1) + '.pth.tar') torch.save(model.state_dict(), PATH) print("Save model at {}\n".format(PATH)) writer.close()
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Device being used:", device) with open('./dataloaders/ucf_labels.txt', 'r') as f: class_names = f.readlines() f.close() # init model model = C3D_model.C3D(num_classes=101) checkpoint = torch.load('run/run_10/models/C3D-ucf101_epoch-99.pth.tar', map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) model.to(device) model.train() # read video # video = '/data/Sadjad/Datasets/ucf101/UCF-101/HandstandWalking/v_HandstandWalking_g22_c04.avi' # Haircut/v_Haircut_g03_c01.avi' # FrontCrawl/v_FrontCrawl_g07_c05.avi' # HulaHoop/v_HulaHoop_g02_c04.avi' # Biking/v_Biking_g06_c05.avi' # GolfSwing/v_GolfSwing_g11_c01.avi' # hmdb51/videos/dive/Extreme_Cliffdiving_dive_f_cm_np1_le_bad_2.avi' # ucf101/UCF-101/HighJump/v_HighJump_g07_c03.avi' # Skiing/v_Skiing_g09_c05.avi' # Archery/v_Archery_g01_c03.avi' # '/data/Sadjad/Datasets/ucf101/UCF-101/Knitting/v_Knitting_g03_c05.avi' # '/data/Sadjad/Datasets/DALY/download_videos/videos/3\ WAYS\ OF\ APPLYING\ RED\ LIPSTICK\ l\ Pearltji-YCqSlzeFvn4.mp4' # '/data/Sadjad/Datasets/ucf101/UCF-101/StillRings/v_StillRings_g04_c02.avi' # capwrite = cv2.VideoCapture() cap = cv2.VideoCapture(0) # video) # fourcc = cv2.VideoWriter_fourcc(*'DIVX') # MJPG') #size = ( #int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), #int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) #) # out = cv2.VideoWriter('6.mp4',fourcc, 25, size) # out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480)) retaining = True clip = [] while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, (171, 128))) tmp = tmp_ - np.array([[[90.0, 98.0, 102.0]]]) clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable(inputs, requires_grad=False).to(device) with torch.no_grad(): outputs = model.forward(inputs) probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] cv2.putText(frame, class_names[label].split(' ')[-1].strip(), (20, 210), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0), 1) cv2.putText(frame, "acc: %.4f" % probs[0][label], (20, 230), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 0), 1) clip.pop(0) # out.write(frame) cv2.imshow('result', frame) #cv2.waitKey(30) # out.release() cap.release() cv2.destroyAllWindows()
def train_model(dataset=dataset, save_dir=SAVE_FILE_FOLDER, num_classes=num_classes, lr=lr, num_epochs=nEpochs, save_epoch=snapshot, useTest=useTest, test_interval=nTestInterval): """ Args: num_classes (int): Number of classes in the data num_epochs (int, optional): Number of epochs to train for. """ if modelName == 'C3D': model = C3D_model.C3D(num_classes=num_classes, pretrained=IF_PRETRAIN) train_params = [{'params': C3D_model.get_1x_lr_params(model), 'lr': lr}, {'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10}] elif modelName == 'C3D_td5': model = C3D_model.C3D_td5(num_classes=num_classes, pretrained=IF_PRETRAIN) train_params = [{'params': C3D_model.get_1x_lr_params(model), 'lr': lr}, {'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10}] elif modelName == 'R2Plus1D': model = R2Plus1D_model.R2Plus1DClassifier(num_classes=num_classes, layer_sizes=(2, 2, 2, 2)) train_params = [{'params': R2Plus1D_model.get_1x_lr_params(model), 'lr': lr}, {'params': R2Plus1D_model.get_10x_lr_params(model), 'lr': lr * 10}] elif modelName == 'R3D': model = R3D_model.R3DClassifier(num_classes=num_classes, layer_sizes=(2, 2, 2, 2)) train_params = model.parameters() else: print('We only implemented C3D and R2Plus1D models.') raise NotImplementedError criterion = nn.CrossEntropyLoss() # standard crossentropy loss for classification if _optimizer == "SGD": optimizer = optim.SGD(train_params, lr=lr, momentum=MOMENTUM, weight_decay=WD) elif _optimizer == "Adam": optimizer = optim.Adam(train_params, lr=lr, weight_decay=WD) # print(optimizer) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=SCHEDULER_STEP_SIZE, gamma=SCHEDULER_GAMMA) # the scheduler divides the lr by 10 every 10 epochs model.to(device) criterion.to(device) # if resume_epoch == 0: if resume_model_path == None: print("Training {} from scratch...".format(modelName)) else: checkpoint = torch.load( resume_model_path, map_location=lambda storage, loc: storage) # Load all tensors onto the CPU print("Initializing weights from: {}...".format(resume_model_path)) model.load_state_dict(checkpoint['state_dict']) if RESUM_OPTIMIZER: optimizer.load_state_dict(checkpoint['opt_dict']) # resume_epoch # else: # checkpoint = torch.load(os.path.join(SAVE_FILE_FOLDER, 'models', EXP_NAME + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'), # map_location=lambda storage, loc: storage) # Load all tensors onto the CPU # print("Initializing weights from: {}...".format( # os.path.join(SAVE_FILE_FOLDER, EXP_NAME + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'))) # model.load_state_dict(checkpoint['state_dict']) # optimizer.load_state_dict(checkpoint['opt_dict']) print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) model.to(device) criterion.to(device) writer = SummaryWriter(logdir=LOG_PATH) print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train', clip_len=clip_len, preprocess=IF_PREPROCESS_TRAIN, grayscale=grayscale), batch_size=BS, shuffle=True, num_workers=N_WORKERS) val_dataloader = DataLoader(VideoDataset(dataset=dataset, split='val', clip_len=clip_len, preprocess=IF_PREPROCESS_VAL, grayscale=grayscale), batch_size=BS, num_workers=N_WORKERS) test_dataloader = DataLoader(VideoDataset(dataset=dataset, split='test', clip_len=clip_len, preprocess=IF_PREPROCESS_TEST, grayscale=grayscale), batch_size=BS, num_workers=N_WORKERS) trainval_loaders = {'train': train_dataloader, 'val': val_dataloader} trainval_sizes = {x: len(trainval_loaders[x].dataset) for x in ['train', 'val']} test_size = len(test_dataloader.dataset) cudnn.benchmark = True global_best_val_acc = 0 for epoch in range(num_epochs): # each epoch has a training and validation step for phase in ['train', 'val']: start_time = timeit.default_timer() # reset the running loss and corrects running_loss = 0.0 running_corrects = 0.0 # running_roc = 0.0 list_pred = list() list_label = list() # print(optimizer) # set model to train() or eval() mode depending on whether it is trained # or being validated. Primarily affects layers such as BatchNorm or Dropout. if phase == 'train': # scheduler.step() is to be called once every epoch during training scheduler.step() model.train() else: model.eval() # for inputs, labels in tqdm(trainval_loaders[phase]): run_count = 0 for inputs, labels in trainval_loaders[phase]: # move inputs and labels to the device the training is taking place on inputs = Variable(inputs, requires_grad=True).to(device) labels = Variable(labels).to(device) optimizer.zero_grad() if phase == 'train': outputs = model(inputs) else: with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels) if phase == 'train': loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) # try: # running_roc += roc_auc_score(labels.data.cpu(), preds.cpu()) # except: # y_true = labels.data.cpu().tolist() # y_true_2 = y_true.copy() # for i_cls in range(N_CLASSES): # y_true_2.append(i_cls) # # y_pred = preds.cpu().tolist() # y_pred_2 = y_pred.copy() # for i_cls in range(N_CLASSES): # y_pred_2.append(i_cls) # # running_roc += roc_auc_score(y_true_2, y_pred_2) # # run_count += 1 list_label += labels.data.cpu().tolist() list_pred += preds.cpu().tolist() epoch_loss = running_loss / trainval_sizes[phase] epoch_acc = running_corrects.double() / trainval_sizes[phase] epoch_roc = multiclass_roc_score(label=list_label, pred=list_pred, n_cls=N_CLASSES) if phase == 'train': writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch) writer.add_scalar('data/train_roc_epoch', epoch_roc, epoch) else: writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch) writer.add_scalar('data/val_roc_epoch', epoch_roc, epoch) # if epoch_acc >= global_best_val_acc: # torch.save({ # 'epoch': epoch + 1, # 'state_dict': model.state_dict(), # 'opt_dict': optimizer.state_dict(), # }, os.path.join(SAVE_FILE_FOLDER, 'models', EXP_NAME + '_epoch-' + str(epoch) + 'ValAcc_{:10.4f}_'.format(epoch_loss) + '.pth.tar')) # print("Save model at {}\n".format( # os.path.join(SAVE_FILE_FOLDER, 'models', EXP_NAME + '_epoch-' + str(epoch) + 'ValAcc_{:10.4f}_'.format(epoch_loss) + '.pth.tar'))) print("[{}] Epoch: {}/{} Loss: {} Acc: {}, ROC:{}".format(phase, epoch+1, nEpochs, epoch_loss, epoch_acc, epoch_roc)) stop_time = timeit.default_timer() # print("Execution time: " + str(stop_time - start_time) + "\n") if epoch % save_epoch == (save_epoch - 1): torch.save({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'opt_dict': optimizer.state_dict(), }, os.path.join(SAVE_FILE_FOLDER, EXP_NAME + '_epoch-' + str(epoch) + '.pth.tar')) print("Save model at {}\n".format(os.path.join(SAVE_FILE_FOLDER, EXP_NAME + '_epoch-' + str(epoch) + '.pth.tar'))) if useTest and epoch % test_interval == (test_interval - 1): model.eval() start_time = timeit.default_timer() running_loss = 0.0 running_corrects = 0.0 # running_roc = 0.0 list_pred = list() list_label = list() # for inputs, labels in tqdm(test_dataloader): run_count = 0 for inputs, labels in test_dataloader: inputs = inputs.to(device) labels = labels.to(device) with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels) running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) # try: # running_roc += roc_auc_score(labels.data.cpu(), preds.cpu()) # except: # running_roc += 0.5 # run_count += 1 list_label += labels.data.cpu().tolist() list_pred += preds.cpu().tolist() epoch_loss = running_loss / test_size epoch_acc = running_corrects.double() / test_size epoch_roc = multiclass_roc_score(label=list_label, pred=list_pred, n_cls=N_CLASSES) writer.add_scalar('data/test_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/test_acc_epoch', epoch_acc, epoch) writer.add_scalar('data/test_roc_epoch', epoch_roc, epoch) print("[test] Epoch: {}/{} Loss: {} Acc:{} ROC: {}".format(epoch+1, nEpochs, epoch_loss, epoch_acc, epoch_roc)) stop_time = timeit.default_timer() # print("Execution time: " + str(stop_time - start_time) + "\n") writer.close()
def train_model(dataset=dataset, save_dir=save_dir, num_classes=num_classes, lr=lr, num_epochs=nEpochs, save_epoch=snapshot, useTest=useTest, test_interval=nTestInterval): """ Args: num_classes (int): Number of classes in the data num_epochs (int, optional): Number of epochs to train for. """ if modelName == 'C3D': model = C3D_model.C3D(num_classes=num_classes, pretrained=True) train_params = [{ 'params': C3D_model.get_1x_lr_params(model), 'lr': lr }, { 'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10 }] elif modelName == 'R2Plus1D': # model = R2Plus1D_model.R2Plus1DClassifier(num_classes=num_classes, layer_sizes=(2, 2, 2, 2)) # train_params = [{'params': R2Plus1D_model.get_1x_lr_params(model), 'lr': lr}, # {'params': R2Plus1D_model.get_10x_lr_params(model), 'lr': lr * 10}] model = models.video.r2plus1d_18(pretrained=True, progress=True) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 2) model = model.to(device) train_params = model.parameters() # for name, param in model.named_parameters(): # print(name, param.data) # jdks elif modelName == 'R3D': # model = R3D_model.R3DClassifier(num_classes=num_classes, layer_sizes=(2, 2, 2, 2)) # train_params = model.parameters() model = models.video.r3d_18(pretrained=True, progress=True) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 2) model = model.to(device) train_params = model.parameters() elif modelName == 'MC3': # model = R3D_model.R3DClassifier(num_classes=num_classes, layer_sizes=(2, 2, 2, 2)) # train_params = model.parameters() model = models.video.mc3_18(pretrained=True, progress=True) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 2) model = model.to(device) train_params = model.parameters() elif modelName == 'I3D': model = I3D.InceptionI3d(num_classes=157) load_file = 'rgb_charades.pt' model = model.to(device) model.load_state_dict(torch.load(load_file)) model.replace_logits(num_classes=2) train_params = model.parameters() else: print('We only implemented C3D and R2Plus1D models.') raise NotImplementedError criterion = nn.CrossEntropyLoss(weight=torch.tensor( [1.0 / 375, 1.0 / 4388])) # standard crossentropy loss for classification optimizer = optim.SGD(train_params, lr=lr, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.StepLR( optimizer, step_size=10, gamma=0.1) # the scheduler divides the lr by 10 every 10 epochs #sampler = torch.utils.data.WeightedRandomSampler([1.0/212, 1.0/4388], 8, replacement=True) if resume_epoch == 0: print("Training {} from scratch...".format(modelName)) else: #checkpoint = torch.load(os.path.join(save_dir, 'checkpoints', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'), # map_location=lambda storage, loc: storage) # Load all tensors onto the CPU #print("Initializing weights from: {}...".format( # os.path.join(save_dir, 'models', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'))) checkpoint = torch.load( 'run\\run_10\\models\\I3D-celeb-df_epoch-19.pth.tar', map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['opt_dict']) print("Chekpoint loaded") print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) model.to(device) criterion.to(device) log_dir = os.path.join( save_dir, 'models', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname()) writer = SummaryWriter(log_dir=log_dir) print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train', clip_len=16, preprocess=False), batch_size=8, shuffle=True, num_workers=4) val_dataloader = DataLoader(VideoDataset(dataset=dataset, split='val', clip_len=16), batch_size=8, num_workers=4, shuffle=True) test_dataloader = DataLoader(VideoDataset(dataset=dataset, split='test', clip_len=16), batch_size=8, num_workers=4, shuffle=True) trainval_loaders = {'train': train_dataloader, 'val': val_dataloader} trainval_sizes = { x: len(trainval_loaders[x].dataset) for x in ['train', 'val'] } test_size = len(test_dataloader.dataset) training_loss_history = [] val_loss_history = [] for epoch in range(resume_epoch, num_epochs): #each epoch has a training and validation step # for phase in ['train', 'val']: # start_time = timeit.default_timer() # # reset the running loss and corrects # running_loss = 0.0 # running_corrects = 0.0 # # set model to train() or eval() mode depending on whether it is trained # # or being validated. Primarily affects layers such as BatchNorm or Dropout. # if phase == 'train': # # scheduler.step() is to be called once every epoch during training # scheduler.step() # model.train() # else: # model.eval() # for inputs, labels in tqdm(trainval_loaders[phase]): # # move inputs and labels to the device the training is taking place on # inputs = Variable(inputs, requires_grad=True).to(device) # labels = Variable(labels).to(device) # optimizer.zero_grad() # if phase == 'train': # outputs = model(inputs) # else: # with torch.no_grad(): # outputs = model(inputs) # probs = nn.Softmax(dim=1)(outputs) # preds = torch.max(probs, 1)[1] # loss = criterion(outputs, labels.type(torch.long)) # if phase == 'train': # loss.backward() # #torch.nn.utils.clip_grad_norm_(model.parameters(), 1) # optimizer.step() # training_loss_history.append(loss.item()) # else: # val_loss_history.append(loss.item()) # running_loss += loss.item() * inputs.size(0) # running_corrects += torch.sum(preds == labels.data) # #print("Running loss: ", running_loss) # #print("Running corrects: ", running_corrects) # epoch_loss = running_loss / trainval_sizes[phase] # epoch_acc = running_corrects.double() / trainval_sizes[phase] # if phase == 'train': # writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch) # writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch) # else: # writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch) # writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch) # save_loss(training_loss_history, val_loss_history) # print("[{}] Epoch: {}/{} Loss: {} Acc: {}".format(phase, epoch+1, nEpochs, epoch_loss, epoch_acc)) # stop_time = timeit.default_timer() # print("Execution time: " + str(stop_time - start_time) + "\n") # if epoch % save_epoch == (save_epoch - 1): # torch.save({ # 'epoch': epoch + 1, # 'state_dict': model.state_dict(), # 'opt_dict': optimizer.state_dict(), # }, os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar')) # print("Save model at {}\n".format(os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar'))) if useTest and epoch % test_interval == (test_interval - 1): model.eval() start_time = timeit.default_timer() running_loss = 0.0 running_corrects = 0.0 cat_probs = None cat_labels = None for inputs, labels in tqdm(test_dataloader): inputs = inputs.to(device) labels = labels.to(device) with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels.type(torch.long)) if type(cat_probs) != type(None): cat_probs = torch.cat((cat_probs, probs), dim=0) cat_labels = torch.cat((cat_labels, labels), dim=0) else: cat_probs = probs cat_labels = labels running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) save_roc_curve(cat_labels, cat_probs) epoch_loss = running_loss / test_size epoch_acc = running_corrects.double() / test_size writer.add_scalar('data/test_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/test_acc_epoch', epoch_acc, epoch) print("[test] Epoch: {}/{} Loss: {} Acc: {}".format( epoch + 1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") writer.close()
def main(): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Device being used:", device) with open('./dataloaders/ferryboat_labels.txt', 'r') as f: class_names = f.readlines() f.close() # init model num_classes = 4 modelName = 'STP' if modelName == 'I3D': model = I3D_model.InceptionI3d(num_classes=num_classes, in_channels=3) size = (240, 284) crop_size = 224 elif modelName == 'R2Plus1D': model = R2Plus1D_model.R2Plus1DClassifier(num_classes=num_classes, layer_sizes=(3, 4, 6, 3)) size = (171, 128) crop_size = 112 elif modelName == 'C3D': model = C3D_model.C3D(num_classes=num_classes, pretrained=False) size = (171, 128) crop_size = 112 elif modelName == 'P3D': model = p3d_model.P3D63(num_classes=num_classes) size = (176, 210) crop_size = 160 elif modelName == 'R3D': model = R3D_model.R3DClassifier(num_classes=num_classes, layer_sizes=(3, 4, 6, 3)) size = (171, 128) crop_size = 112 elif modelName == 'STP': model = STP_model.STP(num_classes=num_classes, in_channels=3) size = (240, 284) crop_size = 224 checkpoint = torch.load('./models/I3D-ferryboat4_epoch-199.pth.tar', map_location=lambda storage, loc: storage) model_dict = model.state_dict() checkpoint_load = { k: v for k, v in (checkpoint['state_dict']).items() if k in model_dict } model_dict.update(checkpoint_load) model.load_state_dict(model_dict) model.to(device) model.eval() for root, dirs, files in os.walk('./VAR/ferryboat/test/'): l_names = locals() l_names['Inshore'] = 0 l_names['Neg'] = 0 l_names['Offshore'] = 0 l_names['Traffic'] = 0 l_names['Inshore1'] = 0 l_names['Neg1'] = 0 l_names['Offshore1'] = 0 l_names['Traffic1'] = 0 if len(dirs) > 4: video_name = dirs for name in video_name: class_name = name.split('_')[1] video = './ferryboat/' + class_name + "/" + name + '.avi' clip = [] cap = cv2.VideoCapture(video) retaining = True while retaining: retaining, frame = cap.read() if not retaining and frame is None: continue tmp_ = center_crop(cv2.resize(frame, size), crop_size) tmp = tmp_ clip.append(tmp) if len(clip) == 16: inputs = np.array(clip).astype(np.float32) inputs = np.expand_dims(inputs, axis=0) inputs = np.transpose(inputs, (0, 4, 1, 2, 3)) inputs = torch.from_numpy(inputs) inputs = torch.autograd.Variable( inputs, requires_grad=False).to(device) with torch.no_grad(): if modelName == 'STP': outputs, index = model.forward(inputs) else: outputs = model.forward(inputs) iii = index.cpu().data probs = torch.nn.Softmax(dim=1)(outputs) label = torch.max(probs, 1)[1].detach().cpu().numpy()[0] if modelName == 'I3D': label = int(label[0]) pre = class_names[label].split(' ')[1][:-1] l_names[str(class_name)] = l_names[str(class_name)] + 1 if str(pre) == str(class_name): l_names[str(class_name) + '1'] = l_names[str(class_name) + '1'] + 1 elif str(class_name) == 'Neg': l_names[str(class_name) + '1'] = l_names[str(class_name) + '1'] + 1 elif str(class_name) == 'Traffic': l_names[str(class_name) + '1'] = l_names[str(class_name) + '1'] + 1 clip.pop(0) cv2.waitKey(30) cap.release() cv2.destroyAllWindows() print( str(class_name) + '_acc:' + str( int(l_names[str(class_name) + '1']) / int(l_names[str(class_name)])))
def run(self, neuron_list): named_children = list(self.mdl.named_children()) for n, c in named_children: print(f"Now visualising filters in {n}") if __name__ == '__main__': sys.path.append('/home/hileyl/scratch/Projects/PyTorch/pytorch-video-recognition/') from network import C3D_model import collections mdl = C3D_model.C3D(101) if hasattr(mdl, "module"): module = mdl.module else: module = mdl state = torch.load('save_20.pth') n_state = [] for k, v in state['state_dict'].items(): if 'module' in k: n_state.append((k[7:], v)) if n_state == []: n_state = state['state_dict'] else: n_state = collections.OrderedDict(n_state) mdl.load_state_dict(n_state)
def train_model(dataset=dataset, save_dir=save_dir, num_classes=num_classes, lr=lr, num_epochs=nEpochs, save_epoch=snapshot, useTest=useTest, test_interval=nTestInterval): """ Args: num_classes (int): Number of classes in the data num_epochs (int, optional): Number of epochs to train for. """ if modelName == 'C3D': model = C3D_model.C3D(num_classes=num_classes, pretrained=False) train_params = [{'params': C3D_model.get_1x_lr_params(model), 'lr': lr}, {'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10}] elif modelName == 'R2Plus1D': model = R2Plus1D_model.R2Plus1DClassifier(num_classes=num_classes, layer_sizes=(2, 2, 2, 2)) train_params = [{'params': R2Plus1D_model.get_1x_lr_params(model), 'lr': lr}, {'params': R2Plus1D_model.get_10x_lr_params(model), 'lr': lr * 10}] elif modelName == 'R3D': model = R3D_model.R3DClassifier(num_classes=num_classes, layer_sizes=(3, 4, 6, 3)) # model = resnet.ResNet(num_classes=num_classes, layers=(3, 4, 6, 3), sample_size=112, sample_duration=16) train_params = model.parameters() elif modelName == 'R2D': model = R2Dnet.R2DClassifier(group_num_classes=num_classes, pretrained=True) # model = resnet.ResNet(num_classes=num_classes, layers=(3, 4, 6, 3), sample_size=112, sample_duration=16) train_params = model.parameters() else: print('We only implemented C3D and R2Plus1D models.') raise NotImplementedError criterion = nn.CrossEntropyLoss() # standard crossentropy loss for classification optimizer = optim.SGD(train_params, lr=lr, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) # the scheduler divides the lr by 10 every 10 epochs model.to(device) #move here because resume need .cuda() if resume_epoch == 0: print("Training {} from scratch...".format(modelName)) else: checkpoint = torch.load(os.path.join(save_dir, 'models', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'), map_location=lambda storage, loc: storage) # Load all tensors onto the CPU print("Initializing weights from: {}...".format( os.path.join(save_dir, 'models', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'))) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['opt_dict']) print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) # model.to(device) criterion.to(device) log_dir = os.path.join(save_dir, 'models', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname()) writer = SummaryWriter(log_dir=log_dir) print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VolleyballDataset(dataset=dataset, split='train',clip_len=16), batch_size=4, shuffle=True, \ num_workers=0) val_dataloader = DataLoader(VolleyballDataset(dataset=dataset, split='val', clip_len=16), batch_size=4, num_workers=0) test_dataloader = DataLoader(VolleyballDataset(dataset=dataset, split='test', clip_len=16), batch_size=4, num_workers=0) trainval_loaders = {'train': train_dataloader, 'val': val_dataloader} trainval_sizes = {x: len(trainval_loaders[x].dataset) for x in ['train', 'val']} test_size = len(test_dataloader.dataset) for epoch in range(resume_epoch, num_epochs): # each epoch has a training and validation step for phase in ['train', 'val']: start_time = timeit.default_timer() # reset the running loss and corrects running_loss = 0.0 running_corrects = 0.0 # set model to train() or eval() mode depending on whether it is trained # or being validated. Primarily affects layers such as BatchNorm or Dropout. if phase == 'train': # scheduler.step() is to be called once every epoch during training scheduler.step() model.train() else: model.eval() torch.backends.cudnn.benchmark=False # for inputs, bbox_inputs, labels, adjacent_matrix in tqdm(trainval_loaders[phase]): # for inputs, labels in tqdm(trainval_loaders[phase]): for inputs, labels, dists in tqdm(trainval_loaders[phase]): # move inputs and labels to the device the training is taking place on inputs = Variable(inputs, requires_grad=True).to(device) # bbox_inputs = Variable(bbox_inputs, requires_grad=True).to(device) # adjacent_matrix = Variable(adjacent_matrix, requires_grad=True).to(device) labels = Variable(labels).to(device) dists = Variable(dists, requires_grad = True).to(device) # dist_num = Variable(dist_num).to(device) optimizer.zero_grad() if phase == 'train': outputs = model(inputs, dists) # outputs = model(inputs, bbox_inputs, adjacent_matrix) else: with torch.no_grad(): # outputs = model(inputs, bbox_inputs, adjacent_matrix) outputs = model(inputs, dists) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels) print("labels",labels) print("outputs",outputs) print("loss",loss) torch.backends.cudnn.benchmark = False if phase == 'train': loss.backward(retain_graph=True) optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / trainval_sizes[phase] epoch_acc = running_corrects.double() / trainval_sizes[phase] if phase == 'train': writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch) else: writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch) print("[{}] Epoch: {}/{} Loss: {} Acc: {}".format(phase, epoch+1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") if epoch % save_epoch == (save_epoch - 1): print(os.path.join(save_dir, 'models', saveName + \ '_epoch-' + str(epoch) + '.pth.tar')) torch.save({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'opt_dict': optimizer.state_dict(), }, os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar')) print("Save model at {}\n".format(os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar'))) if useTest and epoch % test_interval == (test_interval - 1): model.eval() start_time = timeit.default_timer() running_loss = 0.0 running_corrects = 0.0 for inputs, bbox_inputs, labels, adjacent_matrix in tqdm(test_dataloader): # for inputs, labels in tqdm(test_dataloader): bbox_inputs = Variable(bbox_inputs, requires_grad=True).to(device) adjacent_matrix = Variable(adjacent_matrix, requires_grad=True).to(device) inputs = Variable(inputs.to(device)) with torch.no_grad(): # outputs = model(inputs) outputs = model(inputs, bbox_inputs, adjacent_matrix) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels) running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / test_size epoch_acc = running_corrects.double() / test_size writer.add_scalar('data/test_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/test_acc_epoch', epoch_acc, epoch) print("[test] Epoch: {}/{} Loss: {} Acc: {}".format(epoch+1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") writer.close()
def train_model(dataset=dataset, num_classes=num_classes, lr=lr, num_epochs=nEpochs, save_epoch=snapshot): """ Args: num_classes (int): Number of classes in the data num_epochs (int, optional): Number of epochs to train for. """ if modelName == 'C3D': model = C3D_model.C3D(num_classes=num_classes, pretrained=True) train_params = [{ 'params': C3D_model.get_1x_lr_params(model), 'lr': lr }, { 'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10 }] elif modelName == 'resnet': model = resnet.generate_model(model_depth=50, n_classes=700, n_input_channels=3, shortcut_type='B', conv1_t_size=7, conv1_t_stride=1, no_max_pool=False, widen_factor=1.0) model = resnet.load_pretrained_model(model, 'network/r3d50_K_200ep.pth', modelName, num_classes) train_params = resnet.get_fine_tuning_parameters(model, 'fc') criterion = nn.CrossEntropyLoss( ) # standard crossentropy loss for classification optimizer = optim.SGD(train_params, lr=lr, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.StepLR( optimizer, step_size=10, gamma=0.1) # the scheduler divides the lr by 10 every 10 epochs print("Training {} from scratch...".format(modelName)) print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) model.to(device) criterion.to(device) print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train', clip_len=16), batch_size=20, shuffle=True, num_workers=4) train_size = len(train_dataloader.dataset) for epoch in range(0, num_epochs): start_time = timeit.default_timer() # reset the running loss and corrects running_loss = 0.0 running_corrects = 0.0 # scheduler.step() is to be called once every epoch during training scheduler.step() model.train() for inputs, labels in tqdm(train_dataloader): # move inputs and labels to the device the training is taking place on inputs = Variable(inputs, requires_grad=True).to(device) labels = Variable(labels).to(device) optimizer.zero_grad() outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / train_size epoch_acc = running_corrects.double() / train_size print("[{}] Epoch: {}/{} Loss: {} Acc: {}".format( phase, epoch + 1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") if epoch % save_epoch == (save_epoch - 1): torch.save( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'opt_dict': optimizer.state_dict(), }, os.path.join(str(epoch) + '.pth'))
def train_model(dataset=dataset, save_dir=save_dir, num_classes=num_classes, lr=lr, num_epochs=nEpochs, save_epoch=snapshot, useTest=useTest, test_interval=nTestInterval): """ Args: num_classes (int): Number of classes in the data num_epochs (int, optional): Number of epochs to train for. """ if modelName == 'C3D': model = C3D_model.C3D(num_classes=num_classes, pretrained=True) train_params = [{'params': C3D_model.get_1x_lr_params(model), 'lr': lr}, {'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10}] else: print('We only implemented C3D models.') raise NotImplementedError criterion = nn.CrossEntropyLoss() # standard crossentropy loss for classification optimizer = optim.SGD(train_params, lr=lr, momentum=0.9, weight_decay=5e-4) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) # the scheduler divides the lr by 10 every 10 epochs if resume_epoch == 0: print("Training {} from scratch...".format(modelName)) else: checkpoint = torch.load(os.path.join(save_dir, 'models', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'), map_location=lambda storage, loc: storage) # Load all tensors onto the CPU print("Initializing weights from: {}...".format( os.path.join(save_dir, 'models', saveName + '_epoch-' + str(resume_epoch - 1) + '.pth.tar'))) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['opt_dict']) print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) model.to(device) criterion.to(device) log_dir = os.path.join(save_dir, 'models', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname()) writer = SummaryWriter(log_dir=log_dir) print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train',clip_len=16), batch_size=1, shuffle=True, num_workers=0) val_dataloader = DataLoader(VideoDataset(dataset=dataset, split='val', clip_len=16), batch_size=1, num_workers=0) test_dataloader = DataLoader(VideoDataset(dataset=dataset, split='test', clip_len=16), batch_size=1, num_workers=0) trainval_loaders = {'train': train_dataloader, 'val': val_dataloader} trainval_sizes = {x: len(trainval_loaders[x].dataset) for x in ['train', 'val']} test_size = len(test_dataloader.dataset) for epoch in range(resume_epoch, num_epochs): # each epoch has a training and validation step for phase in ['train', 'val']: start_time = timeit.default_timer() # reset the running loss and corrects running_loss = 0.0 running_corrects = 0.0 # set model to train() or eval() mode depending on whether it is trained # or being validated. Primarily affects layers such as BatchNorm or Dropout. if phase == 'train': # scheduler.step() is to be called once every epoch during training scheduler.step() model.train() else: model.eval() for inputs, labels in tqdm(trainval_loaders[phase]): # move inputs and labels to the device the training is taking place on inputs = Variable(inputs, requires_grad=True).to(device) labels = Variable(labels).to(device) optimizer.zero_grad() if phase == 'train': outputs = model(inputs) else: with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] labels=labels.long() loss = criterion(outputs, labels) if phase == 'train': loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / trainval_sizes[phase] epoch_acc = running_corrects.double() / trainval_sizes[phase] if phase == 'train': writer.add_scalar('data/train_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/train_acc_epoch', epoch_acc, epoch) else: writer.add_scalar('data/val_loss_epoch', epoch_loss, epoch) writer.add_scalar('data/val_acc_epoch', epoch_acc, epoch) print("[{}] Epoch: {}/{} Loss: {} Acc: {}".format(phase, epoch+1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") if epoch % save_epoch == (save_epoch - 1): torch.save({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'opt_dict': optimizer.state_dict(), }, os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar')) print("Save model at {}\n".format(os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar'))) writer.close()
def train_model(dataset=dataset, save_dir=save_dir, num_classes=num_classes, lr=lr, num_epochs=nEpochs, save_epoch=snapshot, useTest=useTest, test_interval=nTestInterval): # 1 导入模型 model = C3D_model.C3D(num_classes=num_classes, pretrained=False) train_params = [{ 'params': C3D_model.get_1x_lr_params(model), 'lr': lr }, { 'params': C3D_model.get_10x_lr_params(model), 'lr': lr * 10 }] # 2 损失函数 criterion = nn.CrossEntropyLoss() # 3 优化函数 optimizer = optim.SGD(train_params, lr=lr, momentum=0.9, weight_decay=5e-4) # 4 学习率下降 scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1) print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) model.cuda() criterion.cuda() # 6 设置训练集和测试机 print('Training model on {} dataset...'.format(dataset)) train_dataloader = DataLoader(VideoDataset(dataset=dataset, split='train', clip_len=16), batch_size=4, shuffle=True, num_workers=0) val_dataloader = DataLoader(VideoDataset(dataset=dataset, split='val', clip_len=16), batch_size=4, num_workers=0) test_dataloader = DataLoader(VideoDataset(dataset=dataset, split='test', clip_len=16), batch_size=4, num_workers=0) trainval_loaders = {'train': train_dataloader, 'val': val_dataloader} trainval_sizes = { x: len(trainval_loaders[x].dataset) for x in ['train', 'val'] } test_size = len(test_dataloader.dataset) # 8 开始训练模型 for epoch in range(0, num_epochs): for phase in ['train', 'val']: start_time = timeit.default_timer() # reset the running loss and corrects running_loss = 0.0 running_corrects = 0.0 if phase == 'train': scheduler.step() model.train() else: model.eval() for inputs, labels in tqdm(trainval_loaders[phase]): inputs = inputs.cuda() labels = labels.cuda() optimizer.zero_grad() # 根据训练集还是测试集进行模型输出选择 if phase == 'train': outputs = model(inputs) else: # 禁用梯度下降上下文管理器 with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels.long()) # 训练集,进行反向传播 if phase == 'train': loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / trainval_sizes[phase] epoch_acc = running_corrects.double() / trainval_sizes[phase] print("[{}] Epoch: {}/{} Loss: {} Acc: {}".format( phase, epoch + 1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n") # 保存模型 if epoch % save_epoch == (save_epoch - 1): torch.save( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'opt_dict': optimizer.state_dict(), }, os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar')) print("Save model at {}\n".format( os.path.join(save_dir, 'models', saveName + '_epoch-' + str(epoch) + '.pth.tar'))) # 走测试集 if useTest and epoch % test_interval == (test_interval - 1): model.eval() start_time = timeit.default_timer() running_loss = 0.0 running_corrects = 0.0 for inputs, labels in tqdm(test_dataloader): inputs = inputs.cuda() labels = labels.cuda() with torch.no_grad(): outputs = model(inputs) probs = nn.Softmax(dim=1)(outputs) preds = torch.max(probs, 1)[1] loss = criterion(outputs, labels.long()) running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / test_size epoch_acc = running_corrects.double() / test_size print("[test] Epoch: {}/{} Loss: {} Acc: {}".format( epoch + 1, nEpochs, epoch_loss, epoch_acc)) stop_time = timeit.default_timer() print("Execution time: " + str(stop_time - start_time) + "\n")