def load_test_pred(video_path,gt_path,model_path):
feature_size = 512 * 7 * 7
CNN_pre_model = torchvision.models.vgg16(pretrained=True).features
model = CNN_model.CNN_model(feature_size)
# GPU enable
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print('Device used:', device)
if torch.cuda.is_available():
CNN_pre_model = CNN_pre_model.to(device)
model = model.to(device)
load_checkpoint(model_path,model)
CNN_pre_model.eval()
# -> label loading
test_label = pd.read_csv(gt_path)["Action_labels"]
test_features = []
category_path = sorted(os.listdir(video_path))
with torch.no_grad():
for category in category_path:
mask = pd.read_csv(gt_path)["Video_category"] == category
test_name = pd.read_csv(gt_path)[mask]["Video_name"]
for i,video_name in enumerate(test_name):
print("\r%d/%d" %(i,len(test_name)),end="")
frames = readShortVideo(video_path,category, video_name,downsample_factor=12, rescale_factor=1)
frames = Variable(torch.from_numpy(frames)).to(device)
tmp = CNN_pre_model(frames).cpu().view(-1, feature_size)
test_features.append(torch.mean(tmp,0).numpy())
print("")
print("Processing [%s] finished!"%(category))
print("Pre-train finished!")
test_features = torch.Tensor(test_features)
model.eval()
feature = Variable(test_features).to(device)
output = model(feature)
pred = torch.argmax(output,1).cpu()
print(pred.shape)
return test_features,pred ,test_label
def main():
# parameters
feature_size = 512 * 7 * 7
learning_rate = 0.0001
num_epochs = 51
batch_size = 64
# create the save log file
print("Create the directory")
if not os.path.exists("./save"):
os.makedirs("./save")
if not os.path.exists("./logfile"):
os.makedirs("./logfile")
if not os.path.exists("./logfile/CNN"):
os.makedirs("./logfile/CNN")
# load my Dataset
train_dataset = CNN_Dataset.CNN_Dataset(mode="train")
test_dataset = CNN_Dataset.CNN_Dataset(mode="valid")
print('the train_dataset has %d size.' % (len(train_dataset.data)))
print('the valid_dataset has %d size.' % (len(test_dataset.data)))
# Pre-train models
CNN_pre_model = torchvision.models.vgg16(pretrained=True).features
model = CNN_model.CNN_model(feature_size)
# GPU enable
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print('Device used:', device)
if torch.cuda.is_available():
CNN_pre_model = CNN_pre_model.to(device)
model = model.to(device)
##################################################################
######### pre-train model vgg16
##################################################################
# train_dataset = (num of data ,data/label ,frames ,3 ,224 ,224)
CNN_pre_model.eval()
train_features = []
with torch.no_grad():
for i in range(len(train_dataset.data)):
print("\r%d/%d" % (i, len(train_dataset.data)), end="")
input = train_dataset[i][0]
input = input.to(device)
tmp = CNN_pre_model(input).cpu().view(-1, feature_size)
train_features.append(torch.mean(tmp, 0).numpy())
print(" Pre-train train_data finished!")
test_features = []
with torch.no_grad():
for i in range(len(test_dataset.data)):
print("\r%d/%d" % (i, len(test_dataset.data)), end="")
input = test_dataset[i][0]
input = input.to(device)
tmp = CNN_pre_model(input).cpu().view(-1, feature_size)
test_features.append(torch.mean(tmp, 0).numpy())
print(" Pre-train test_data finished!")
# update dataset
train_features = torch.Tensor(train_features)
train_label = torch.LongTensor(train_dataset.label)
train_features_dataset = data.TensorDataset(train_features, train_label)
test_features = torch.Tensor(test_features)
test_label = torch.LongTensor(test_dataset.label)
test_features_dataset = data.TensorDataset(test_features, test_label)
train_loader = DataLoader(train_features_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=8)
test_loader = DataLoader(test_features_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=8)
# setup optimizer
optimizer = optim.Adam(model.parameters(),
lr=learning_rate,
betas=(0.5, 0.999))
criterion = nn.CrossEntropyLoss()
train_loss_list = []
train_acc_list = []
test_loss_list = []
test_acc_list = []
print("Starting training...")
best_accuracy = -np.inf
for epoch in range(num_epochs):
start = time.time()
model.train()
print("Epoch:", epoch + 1)
epoch_train_loss = 0.0
train_acc = 0.0
if (epoch + 1) == 11:
optimizer.param_groups[0]['lr'] /= 2
if (epoch + 1) == 20:
optimizer.param_groups[0]['lr'] /= 2
for i, (feature, label) in enumerate(train_loader):
feature = Variable(feature).to(device)
label = Variable(label).to(device)
optimizer.zero_grad()
output = model(feature)
train_loss = criterion(output, label)
train_loss.backward()
optimizer.step()
epoch_train_loss += train_loss.item()
# Accuracy
output_label = torch.argmax(output, 1).cpu()
acc = np.mean((output_label == label.cpu()).numpy())
train_acc += acc
print('Epoch [%d/%d], Iter [%d/%d] loss %.4f,Acc %.4f, LR = %.6f' %
(epoch, num_epochs, i + 1, len(train_loader),
train_loss.item(), acc, optimizer.param_groups[0]['lr']))
if (epoch) % 10 == 0:
save_checkpoint('./save/CNN-%03i.pth' % (epoch), model, optimizer)
# testing
with torch.no_grad():
model.eval()
epoch_test_loss = 0.0
test_acc = 0.
for i, (feature, label) in enumerate(test_loader):
feature = Variable(feature).to(device)
label = Variable(label).to(device)
output = model(feature)
test_loss = criterion(output, label)
predict = torch.argmax(output, 1).cpu()
acc = np.mean((predict == label.cpu()).numpy())
epoch_test_loss += test_loss.item()
test_acc += acc
print(
'\n============\nEpoch [%d/%d] ,Train: Loss: %.4f | Acc: %.4f ,Validation: loss: %.4f | Acc: %.4f'
% (epoch, num_epochs, epoch_train_loss / len(train_loader),
train_acc / len(train_loader), epoch_test_loss /
len(test_loader), test_acc / len(test_loader)))
# save loss data
train_loss_list.append(epoch_train_loss / len(train_loader))
train_acc_list.append(train_acc / len(train_loader))
test_loss_list.append(epoch_test_loss / len(test_loader))
test_acc_list.append(test_acc / len(test_loader))
if (test_acc / len(test_loader) > best_accuracy):
best_accuracy = test_acc / len(test_loader)
save_checkpoint('./save/CNN-%03i.pth' % (epoch), model, optimizer)
print('Save best model , test_acc = %.6f)...' % (best_accuracy))
print('-' * 88)
with open('./logfile/CNN/train_loss.pkl', 'wb') as f:
pickle.dump(train_loss_list, f)
with open('./logfile/CNN/train_acc.pkl', 'wb') as f:
pickle.dump(train_acc_list, f)
with open('./logfile/CNN/test_loss.pkl', 'wb') as f:
pickle.dump(test_loss_list, f)
with open('./logfile/CNN/test_acc.pkl', 'wb') as f:
pickle.dump(test_acc_list, f)