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')