def __init__(self, n_class=7): super(VideoNet, self).__init__() self.video_layer = P3D199(pretrained=False, num_classes=101) self.dropout = nn.Dropout(p=0.5) self.relu = nn.ReLU() self.fc = nn.Linear(2048, n_class) self.p1 = nn.Linear(2048, 1024) self.p2 = nn.Linear(1024, 512) self.p3 = nn.Linear(512, 1)
def main(): base_model = P3D199(pretrained=True) num_ftrs = base_model.fc.in_features base_model.fc = nn.Linear(num_ftrs, 101) num_segments = 2 model = TSN(101, num_segments, "RGB", base_model, new_length=16) model = model.cuda() criterion = nn.CrossEntropyLoss().cuda() cudnn.benchmark = True model = nn.DataParallel(model, device_ids=[0, 1]) policies = get_optim_policies(model) learning_rate = 0.001 weight_decay = 0 optimizer = optim.SGD(policies, lr=learning_rate, momentum=0.9, weight_decay=weight_decay) start_epoch = 0 epochs = 90 best_prec1 = 0 resume = 'checkpoint.pth.tar' if os.path.isfile(resume): checkpoint = torch.load(resume) start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( resume, checkpoint['epoch'])) for epoch in range(start_epoch, epochs): adjust_learning_rate(learning_rate, weight_decay, optimizer, epoch) train(train_loader, model, criterion, optimizer, epoch) prec1 = val(val_loader, model, criterion) is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best)
def __init__(self): super(VARN, self).__init__() self.video_layer = P3D199(pretrained=False, num_classes=101) self.audio_layer = nn.Sequential( nn.Conv1d(1, 16, 64, 2, padding=32), nn.MaxPool1d(8, 1, padding=0), nn.Conv1d(16, 32, 32, padding=16), nn.MaxPool1d(8, 1, padding=0), nn.Conv1d(32, 64, 16, 2, padding=8), nn.Conv1d(64, 128, 8, 2, padding=4), nn.Conv1d(128, 256, 4, 2, padding=2), nn.MaxPool1d(4, 1, padding=0), nn.Conv1d(256, 512, 4, 2, padding=2), nn.Conv1d(512, 1024, 4, 2, padding=2) ) self.fusion = nn.Linear(16384, 4096) # self.reason_f1 = nn.Linear(2048, 1024) # self.reason_f2 = nn.Linear(1024, 512) # self.reason_f3 = nn.Linear(512, 7) # self.predict_f1 = nn.Linear(2048, 1024) # self.predict_f2 = nn.Linear(1024, 512) # self.predict_f3 = nn.Linear(512, 1) # Reason layer self.reason_1 = nn.Linear(4096, 2048) self.reason_2 = nn.Linear(2048, 512) self.reason_3 = nn.Linear(512, 7) # self.softmax = nn.Softmax() # Predict layer self.predict_1 = nn.Linear(4096, 2048) self.predict_2 = nn.Linear(2048, 512) self.predict_3 = nn.Linear(512, 1) # self.predict_4 = nn.Linear(1024, 1) self.relu = nn.ReLU() self.dropout = nn.Dropout(p=0.5)
TSNDataSet("","tsntest_01.lst", num_segments=2, new_length=16, modality="RGB", image_tmpl="frame{:06d}.jpg", transform=val_transform, random_shift=False), batch_size=1, shuffle=False, num_workers=1, pin_memory=False ) if __name__ == '__main__': base_model = P3D199(pretrained=True) num_ftrs = base_model.fc.in_features base_model.fc = nn.Linear(num_ftrs, 101) model = TSN(101,2,"RGB",base_model,new_length=16) model = nn.DataParallel(model,device_ids=[0,1]) resume = 'best.pth.tar' if os.path.isfile(resume): checkpoint = torch.load(resume,map_location={'cuda:0':'cpu'}) model.load_state_dict(checkpoint['state_dict']) model = model.eval() res = []
def __init__(self, data_path, label_train_file, label_val_file): self.data_size = None self.data_path = data_path # "/media/guo/搬砖BOY/dataset/"#"D:/dataset/"#/media/guo/搬砖BOY/dataset/" self.p3d_model = P3D199(num_classes=50, pretrained=True) self.ch_en_labels = { '宠物狗': 'dog', '宠物猫': 'cat', '宠物鼠': 'rat', '宠物兔子': 'rabbit', '宠物鸟': 'bird', '风景': 'scenery', '风土人情': 'customs', '穿秀': 'clothes showing', '宝宝': 'child', '男生自拍': 'boy selfie', '女生自拍': 'girl selfie', '做甜品': 'dessert', '做海鲜': 'seafood', '做小吃': 'snack', '饮品': 'drinks', '抓娃娃': 'doll catching', '手势舞': 'finger dance', '街舞': 'street dance', '国标舞': 'Ballroom dance', '钢管舞': 'pole dance', '芭蕾舞': 'ballet', '绘画': 'painting', '手写文字': 'handwriting', '咖啡拉花': 'coffee art', '沙画': 'sand art', '史莱姆': 'slime', '折纸': 'origami', '编织': 'weave', '陶艺': 'ceramic art', '手机壳': 'phone shell', '打鼓': 'drum playing', '弹吉他': 'guitar playing', '弹钢琴': 'piano playing', '弹古筝': 'Zheng playing', '拉小提琴': 'violin', '唱歌': 'singing', '游戏': 'game playing', '动漫': 'cartoon', '瑜伽': 'yoga', '健身': 'fitness', '滑板': 'skateboard', '篮球': 'basketball playing', '跑酷': 'parkour', '潜水': 'diving', '台球': 'billiards', '画眉': 'brow makeup', '画眼': 'eye makeup', '唇彩': 'lips makeup', '美甲': 'manicure', '美发': 'hairdressing' } self.label_train = pd.read_csv('./train_label.cvs', header=None, sep=',') # self.load_label(label_train_file,shuffle=False)#pd.read_csv('./train_label.cvs', header=None, # sep=',') # self.load_label(label_train_file,shuffle=True)#("/media/guo/搬砖BOY/English/trainEnglish.txt")#("D:/dataset/English/trainEnglish.txt") self.label_val = pd.read_csv('./val_label.cvs', header=None, sep=',') # self.load_label(label_val_file,shuffle=False)#("/media/guo/搬砖BOY/English/valEnglish.txt")#("D:/dataset/English/valEnglish.txt") self.labels = list(self.ch_en_labels.values())
start = int(len(images) - 16) flow = torch.FloatTensor(channel, num_frame, size, size) for i in range(num_frame): img = Image.open(images[i + start]) img = img.convert('RGB') img = transformations(img) flow[:, i, :, :] = img return flow # Initial the model if model_type == "P3D": model = P3D199(pretrained=False, num_classes=400) elif model_type == "C3D": model = C3D() elif model_type == "I3D": model = I3D(num_classes=101, modality='rgb') else: logging.error("No such model: {0}".format(model_type)) model = transfer_model(model, num_classes=1, model_type=model_type) if use_cuda > 0: model.cuda() logging.info("=> loading checkpoint" + str(load) + ".tar") checkpoint = torch.load('./models/checkpoint' + str(load) + '.tar') start_epoch = checkpoint['epoch']
def listinfo(): model = P3D199(pretrained=False, num_classes=101) print(model)
def main(): gc.collect() torch.cuda.empty_cache() ucf101_train = UCF101_train('ucfInfo/trainlist03.csv', 'ucf_jpegs_256', transforms.Compose([ Rescale(), RandomCrop(), ToTensor(), Normalize()])) ucf101_valid = UCF101_valid('ucfInfo/validlist03.csv', 'ucf_jpegs_256', transforms.Compose([ Rescale(), RandomCrop(), ToTensor(), Normalize()])) train_loader = DataLoader(ucf101_train, batch_size=4, shuffle=True, num_workers=2, pin_memory=True) valid_loader = DataLoader(ucf101_valid, batch_size=4, shuffle=False, num_workers=2) model = P3D199(pretrained=False, num_classes=101) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=LR, momentum=0.9) start_epoch = 0 # baseline = 1 / 101 best_prec1 = 0.009 # pretrain model if RESUME: if os.path.isfile(CHECKPOINT_MODEL): checkpoint = torch.load(CHECKPOINT_MODEL) start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {}) Prec@1 {}" .format(CHECKPOINT_MODEL, checkpoint['epoch'], best_prec1)) else: print("=> no checkpoint found at '{}'".format(CHECKPOINT_MODEL)) # model = C3D().cuda() model = model.cuda() start = time.time() for epoch in range(start_epoch, _EPOCH): adjust_learning_rate(optimizer, epoch) train(train_loader, model, criterion, optimizer, epoch) prec1 = validate(valid_loader, model, criterion) is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) # save model state save_checkpoint({ 'epoch': epoch + 1, 'arch': 'P3D', 'state_dict': model.state_dict(), 'best_prec1': best_prec1, 'optimizer': optimizer.state_dict(), }, is_best) print('Training_set: 03') print('Execute Time: ', time.time() - start) gc.collect() torch.cuda.empty_cache()
def main(options): # Path configuration machine = options.machine split = options.split # Path to the directories of features and labels if machine == 'ye_home': train_file = '/home/ye/Works/C3D-TCN-Keras/ucfTrainTestlist/trainlist0' + str( split) + '.txt' test_file = '/home/ye/Works/C3D-TCN-Keras/ucfTrainTestlist/testlist0' + str( split) + '.txt' data_folder = '/home/ye/Works/C3D-TCN-Keras/frames' label_file = '/home/ye/Works/C3D-TCN-Keras/ucfTrainTestlist/classInd.txt' elif machine == 'marcc': train_file = './ucfTrainTestlist/trainlist0' + str(split) + '.txt' test_file = './ucfTrainTestlist/testlist0' + str(split) + '.txt' data_folder = './frames' label_file = './ucfTrainTestlist/classInd.txt' if options.model == "C3D": options.size = 112 if options.model == "I3D": options.size = 224 if options.normalize: transformations = transforms.Compose([ transforms.Scale((options.size, options.size)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) else: transformations = transforms.Compose([ transforms.Scale((options.size, options.size)), transforms.ToTensor() ]) if options.dataset == "UCF101": dset_train = ucf101Dataset(data_folder, train_file, label_file, transformations, size=options.size) dset_test = ucf101Dataset(data_folder, test_file, label_file, transformations, size=options.size) elif options.dataset == "kinetics": dset_train = kineticsDataset(data_folder, train_file, label_file, transformations, size=options.size) dset_test = kineticsDataset(data_folder, test_file, label_file, transformations, size=options.size) train_loader = DataLoader( dset_train, batch_size=options.batch_size, shuffle=True, ) test_loader = DataLoader( dset_test, batch_size=options.batch_size, shuffle=False, ) use_cuda = (len(options.gpuid) >= 1) #if options.gpuid: #cuda.set_device(int(options.gpuid[0])) # Initial the model if options.model == "P3D": if options.use_trained_model: model = P3D199(pretrained=True, num_classes=400) else: model = P3D199(pretrained=False, num_classes=400) elif options.model == "C3D": if options.use_trained_model: model = C3D() model.load_state_dict(torch.load('c3d.pickle')) else: model = C3D() elif options.model == "I3D": if options.use_trained_model: model = I3D(num_classes=400, modality='rgb') model.load_state_dict(torch.load('model_rgb.pth')) else: model = I3D(num_classes=101, modality='rgb') else: logging.error("No such model: {0}".format(options.model)) if options.only_last_layer: for param in model.parameters(): param.requires_grad = False model = transfer_model(model, num_classes=101, model_type=options.model) # logging.info("fc size is: {0}".format(model.fc)) if use_cuda > 0: model.cuda() start_epoch = 0 if options.load: logging.info("=> loading checkpoint" + str(options.load) + ".tar") checkpoint = torch.load('checkpoint' + str(options.load) + '.tar') start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) # Binary cross-entropy loss criterion = torch.nn.CrossEntropyLoss() if options.only_last_layer: optimizer = eval("torch.optim." + options.optimizer)( model.fc.parameters(), lr=options.learning_rate) else: if options.optimizer == "SGD": if options.use_policy: policies = get_optim_policies(model=model, modality='RGB', enable_pbn=True) optimizer = torch.optim.SGD(policies, options.learning_rate, momentum=0.9, weight_decay=5e-4) else: optimizer = torch.optim.SGD(model.parameters(), options.learning_rate, momentum=0.9, weight_decay=5e-4) else: optimizer = eval("torch.optim." + options.optimizer)( model.parameters(), lr=options.learning_rate) # scheduler = StepLR(optimizer, step_size=options.lr_steps[0], gamma=0.1) # main training loop # last_dev_avg_loss = float("inf") for epoch_i in range(start_epoch, options.epochs): logging.info("At {0}-th epoch.".format(epoch_i)) # if len(options.lr_steps)>0 and options.use_policy and options.optimizer=="SGD": # adjust_learning_rate(optimizer, epoch_i, options.lr_steps) # else: # scheduler.step() train_loss = 0.0 correct = 0.0 for it, train_data in enumerate(train_loader, 0): vid_tensor, labels = train_data # to_pil_image = ToPILImage() # img = to_pil_image(vid_tensor[0,:,7,:,:]) # img.show() if use_cuda: vid_tensor, labels = Variable(vid_tensor).cuda(), Variable( labels).cuda() else: vid_tensor, labels = Variable(vid_tensor), Variable(labels) model.train() if options.model == "I3D": train_output = model(vid_tensor) train_output = train_output[0] else: train_output = model(vid_tensor) train_output = torch.nn.Softmax(dim=1)(train_output) # print ('vis here!') # vis = make_dot(train_output) # vis.view() # print 'model output shape: ', train_output.size(), ' | label shape: ', labels.size() # print (train_output.size()) loss = criterion(train_output, labels) train_loss += loss.data[0] pred = train_output.data.max( 1, keepdim=True)[1] # get the index of the max log-probability correct += pred.eq(labels.data.view_as(pred)).cpu().sum() if options.batch_size == 1: # print pred.numpy()[0], labels.data.numpy() if pred.cpu().numpy()[0] != labels.cpu().data.numpy(): logging.info("pred: {0}, label: {1}".format( pred.cpu().numpy()[0][0], labels.cpu().data.numpy()[0])) logging.info("loss at batch {0}: {1}".format(it, loss.data[0])) # logging.debug("loss at batch {0}: {1}".format(it, loss.data[0])) optimizer.zero_grad() loss.backward() optimizer.step() if it % 50 == 0: logging.info( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch_i, it * len(vid_tensor), len(train_loader.dataset), 100. * it / len(train_loader), loss.data[0])) train_avg_loss = train_loss / (len(dset_train) / options.batch_size) training_accuracy = (correct / len(dset_train)) logging.info( "Average training loss value per instance is {0} at the end of epoch {1}" .format(train_avg_loss, epoch_i)) logging.info("Training accuracy is {0} at the end of epoch {1}".format( training_accuracy, epoch_i)) if options.save: torch.save( { 'epoch': epoch_i + 1, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), }, 'checkpoint' + str(options.save) + '.tar') # main test loop model.eval() test_loss = 0.0 correct = 0.0 for it, test_data in enumerate(test_loader, 0): vid_tensor, labels = test_data if use_cuda: vid_tensor, labels = Variable(vid_tensor).cuda(), Variable( labels).cuda() else: vid_tensor, labels = Variable(vid_tensor), Variable(labels) if options.model == "I3D": test_output = model(vid_tensor) test_output = test_output[0] else: test_output = model(vid_tensor) test_output = torch.nn.Softmax(dim=1)(test_output) # print 'model output shape: ', test_output.size(), ' | label shape: ', labels.size() # print (test_output.size()) loss = criterion(test_output, labels) test_loss += loss.data[0] pred = test_output.data.max( 1, keepdim=True)[1] # get the index of the max log-probability correct += pred.eq(labels.data.view_as(pred)).cpu().sum() # logging.info("loss at batch {0}: {1}".format(it, loss.data[0])) # logging.debug("loss at batch {0}: {1}".format(it, loss.data[0])) if it % 50 == 0: logging.info('[{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( it * len(vid_tensor), len(test_loader.dataset), 100. * it / len(test_loader), loss.data[0])) test_avg_loss = test_loss / (len(dset_test) / options.batch_size) test_accuracy = (correct / len(dset_test)) logging.info( "Average test loss value per instance is {0}".format(test_avg_loss)) logging.info("Accuracy is {0} ".format(test_accuracy))
def main(options): # Path to the directories of features and labels train_file = './data_files/training_idx.npy' test_file = './data_files/testing_idx.npy' data_folder = './frames' range_file = './data_files/tcn_time_point.npy' if options.task == "score": label_file = './data_files/overall_scores.npy' else: label_file = './data_files/difficulty_level.npy' if options.normalize: transformations = transforms.Compose([transforms.Scale((options.size,options.size)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) else: transformations = transforms.Compose([transforms.Scale((options.size,options.size)), transforms.ToTensor() ]) dset_train = divingDataset(data_folder, train_file, label_file, range_file, transformations, tcn_range=options.tcn_range, random=options.random, size=options.size, downsample=options.downsample, region=options.region) if options.test: # print 'test in train' dset_test = divingDataset(data_folder, test_file, label_file, range_file, transformations, test=True, size=options.size) options.batch_size = 1 else: # print 'no test in train' dset_test = divingDataset(data_folder, test_file, label_file, range_file, transformations, tcn_range=options.tcn_range, random=options.random, test=False, size=options.size, downsample=options.downsample,region=options.region) train_loader = DataLoader(dset_train, batch_size = options.batch_size, shuffle = True, ) test_loader = DataLoader(dset_test, batch_size = int(options.batch_size/2), shuffle = False, ) use_cuda = (len(options.gpuid) >= 1) #if options.gpuid: #cuda.set_device(int(options.gpuid[0])) # Initial the model if options.use_trained_model: model = P3D199(pretrained=True,num_classes=400) else: model = P3D199(pretrained=False,num_classes=400) for param in model.parameters(): param.requires_grad = True if options.only_last_layer: for param in model.parameters(): param.requires_grad = False model = transfer_model(model,num_classes=1, model_type="P3D") if use_cuda > 0: model.cuda() # model = nn.DataParallel(model, devices=gpuid) start_epoch = 0 if options.load: logging.info("=> loading checkpoint"+str(options.load)+".tar") checkpoint = torch.load('./models/checkpoint'+str(options.load)+'.tar') start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) criterion = nn.MSELoss() if options.only_last_layer: optimizer = eval("torch.optim." + options.optimizer)(model.fc.parameters(), lr=options.learning_rate) else: if options.optimizer=="SGD": optimizer = torch.optim.SGD(model.parameters(), options.learning_rate, momentum=0.9, weight_decay=5e-4) else: optimizer = eval("torch.optim." + options.optimizer)(model.parameters(), lr=options.learning_rate) scheduler = StepLR(optimizer, step_size=options.lr_steps[0], gamma=0.1) if not options.test: # main training loop # last_dev_avg_loss = float("inf") for epoch_i in range(0, options.epochs): logging.info("At {0}-th epoch.".format(epoch_i)) scheduler.step() train_loss = 0.0 all_train_output = [] all_labels = [] for it, train_data in enumerate(train_loader, 0): vid_tensor, labels = train_data if use_cuda: vid_tensor, labels = Variable(vid_tensor).cuda(), Variable(labels).cuda() else: vid_tensor, labels = Variable(vid_tensor), Variable(labels) model.train() train_output = model(vid_tensor) train_output = train_output[0] all_train_output = np.append(all_train_output, train_output.data.cpu().numpy()[:,0]) all_labels = np.append(all_labels, labels.data.cpu().numpy()) # print all_train_output, all_labels loss = criterion(train_output, labels) train_loss += loss.data[0] # if it%16 == 0: # print (train_output.data.cpu().numpy()[0][0], '-', labels.data.cpu().numpy()[0]) # logging.info("loss at batch {0}: {1}".format(it, loss.data[0])) optimizer.zero_grad() loss.backward() optimizer.step() train_avg_loss = train_loss / (len(dset_train) / options.batch_size) rho, p_val = spearmanr(all_train_output, all_labels) logging.info("Average training loss value per instance is {0}, the corr is {1} at the end of epoch {2}".format(train_avg_loss, rho, epoch_i)) if options.save: torch.save({ 'epoch': epoch_i + 1, 'state_dict': model.state_dict(), 'optimizer' : optimizer.state_dict(), }, './models/checkpoint'+str(options.save)+'.tar' ) # # main test loop model.eval() test_loss = 0.0 all_test_output = [] all_labels = [] for it, test_data in enumerate(test_loader, 0): vid_tensor, labels = test_data if use_cuda: vid_tensor, labels = Variable(vid_tensor).cuda(), Variable(labels).cuda() else: vid_tensor, labels = Variable(vid_tensor), Variable(labels) test_output = model(vid_tensor) test_output = test_output[0] all_test_output = np.append(all_test_output, test_output.data.cpu().numpy()[:,0]) all_labels = np.append(all_labels, labels.data.cpu().numpy()) loss = criterion(test_output, labels) test_loss += loss.data[0] # if it%8 == 0: # logging.info("loss at batch {0}: {1}".format(it, loss.data[0])) test_avg_loss = test_loss / (len(dset_test) / options.batch_size) # logging.info("Average test loss value per instance is {0}".format(test_avg_loss)) rho, p_val = spearmanr(all_test_output, all_labels) logging.info("Average test loss value per instance is {0}, the corr is {1} at the end of epoch {2}".format(test_avg_loss, rho, epoch_i)) if rho > options.stop: break ####################################################################################################################### # the last test for visualization model.eval() test_loss = 0.0 all_test_output = [] all_labels = [] for it, test_data in enumerate(test_loader, 0): vid_tensor, labels = test_data if use_cuda: vid_tensor, labels = Variable(vid_tensor).cuda(), Variable(labels).cuda() else: vid_tensor, labels = Variable(vid_tensor), Variable(labels) test_output = model(vid_tensor) test_output = test_output[0] all_test_output = np.append(all_test_output, test_output.data.cpu().numpy()[:,0]) all_labels = np.append(all_labels, labels.data.cpu().numpy()) loss = criterion(test_output, labels) test_loss += loss.data[0] test_avg_loss = test_loss / (len(dset_test) / options.batch_size) rho, p_val = spearmanr(all_test_output, all_labels) logging.info("Average test loss value per instance is {0}, the corr is {1}".format(test_avg_loss, rho)) else: # the last test for visualization model.eval() test_loss = 0.0 all_test_output = [] all_labels = [] for it, test_data in enumerate(test_loader, 0): vid_tensors, num_tensor, labels = test_data if use_cuda: labels = Variable(labels).cuda() else: labels = Variable(labels) score = 0.0 for i in range(len(vid_tensors)): vid_tensor = vid_tensors[i] if use_cuda: vid_tensor = Variable(vid_tensor).cuda() else: vid_tensor = Variable(vid_tensor) test_output = model(vid_tensor) test_output = test_output[0] score += test_output.data.cpu().numpy()[:,0][0] score = score/int(num_tensor.numpy()) all_test_output = np.append(all_test_output, score) all_labels = np.append(all_labels, labels.data.cpu().numpy()) for i in range(len(labels.data.cpu().numpy())): logging.info("{0}-{1}".format(test_output.data.cpu().numpy()[i][0], labels.data.cpu().numpy()[i])) rho, p_val = spearmanr(all_test_output, all_labels) logging.info("the corr is {0}".format(rho))
# train(myUCF101,model) test(myUCF101,model,'result4_model.pkl') ''' # model=get_P3D_offset_fyq() # model=model.cuda() # print model # model_init=P3D199(pretrained=True,num_classes=400) # transfer_weights(model_init,model) # model.load_state_dict(torch.load('result5_model_s.pkl')) # train(myUCF101,model) model_init = P3D199(pretrained=True, num_classes=400) model_1 = P3D199(pretrained=False, num_classes=101) model_1 = model_1.cuda() # transfer_weights(model_init,model_1) # train(myUCF101,model_1,'p3d.pkl') # model_2=get_P3D_offset_T_fyq() # model_2=model_2.cuda() # transfer_weights(model_init,model_2) # train(myUCF101,model_2,'p3d_t.pkl') test(myUCF101, model_1, 'p3d.pkl') # test(myUCF101,model_1,'p3d.pkl')