def main():
net = Model(num_class,
args.test_segments,
args.representation,
base_model=args.arch)
checkpoint = torch.load(args.weights)
print("model epoch {} best prec@1: {}".format(checkpoint['epoch'],
checkpoint['best_prec1']))
base_dict = {
'.'.join(k.split('.')[1:]): v
for k, v in list(checkpoint['state_dict'].items())
}
net.load_state_dict(base_dict)
if args.test_crops == 1:
cropping = torchvision.transforms.Compose([
GroupScale(net.scale_size),
GroupCenterCrop(net.crop_size),
])
elif args.test_crops == 10:
cropping = torchvision.transforms.Compose([
GroupOverSample(net.crop_size,
net.scale_size,
is_mv=(args.representation == 'mv'))
])
else:
raise ValueError(
"Only 1 and 10 crops are supported, but got {}.".format(
args.test_crops))
data_loader = torch.utils.data.DataLoader(CoviarDataSet(
args.data_root,
args.data_name,
video_list=args.test_list,
num_segments=args.test_segments,
representation=args.representation,
transform=cropping,
is_train=False,
accumulate=(not args.no_accumulation),
),
batch_size=1,
shuffle=False,
num_workers=args.workers * 2,
pin_memory=True)
if args.gpus is not None:
devices = [args.gpus[i] for i in range(args.workers)]
else:
devices = list(range(args.workers))
net = torch.nn.DataParallel(net.cuda(devices[0]), device_ids=devices)
net.eval()
data_gen = enumerate(data_loader)
total_num = len(data_loader.dataset)
output = []
def forward_video(data):
input_var = torch.autograd.Variable(data, volatile=True)
scores = net(input_var)
scores = scores.view((-1, args.test_segments * args.test_crops) +
scores.size()[1:])
scores = torch.mean(scores, dim=1)
return scores.data.cpu().numpy().copy()
proc_start_time = time.time()
for i, (data, label) in data_gen:
video_scores = forward_video(data)
output.append((video_scores, label[0]))
cnt_time = time.time() - proc_start_time
if (i + 1) % 100 == 0:
print('video {} done, total {}/{}, average {} sec/video'.format(
i, i + 1, total_num,
float(cnt_time) / (i + 1)))
video_pred = [np.argmax(x[0]) for x in output]
video_labels = [x[1] for x in output]
print('Accuracy {:.02f}% ({})'.format(
float(np.sum(np.array(video_pred) == np.array(video_labels))) /
len(video_pred) * 100.0, len(video_pred)))
if args.save_scores is not None:
name_list = [x.strip().split()[0] for x in open(args.test_list)]
order_dict = {e: i for i, e in enumerate(sorted(name_list))}
reorder_output = [None] * len(output)
reorder_label = [None] * len(output)
reorder_name = [None] * len(output)
for i in range(len(output)):
idx = order_dict[name_list[i]]
reorder_output[idx] = output[i]
reorder_label[idx] = video_labels[i]
reorder_name[idx] = name_list[i]
np.savez(args.save_scores,
scores=reorder_output,
labels=reorder_label,
names=reorder_name)
def main():
# define the model
net = Model(num_class,
args.test_segments,
args.representation,
base_model=args.arch,
new_length=args.new_length,
use_databn=args.use_databn,
gen_flow_or_delta=args.gen_flow_or_delta,
gen_flow_ds_factor=args.gen_flow_ds_factor,
arch_estimator=args.arch_estimator,
att=args.att)
# load the trained model
checkpoint = torch.load(args.weights,
map_location=lambda storage, loc: storage)
print("model epoch {} best prec@1: {}".format(checkpoint['epoch'],
checkpoint['best_prec1']))
base_dict = {
'.'.join(k.split('.')[1:]): v
for k, v in list(checkpoint['state_dict'].items())
}
net.load_state_dict(base_dict, strict=False)
# setup the data loader
if args.test_crops == 1:
cropping = torchvision.transforms.Compose([
GroupScale(net.scale_size),
GroupCenterCrop(net.crop_size),
])
elif args.test_crops == 10:
cropping = torchvision.transforms.Compose(
[GroupOverSample(net.crop_size, net.scale_size)])
else:
raise ValueError(
"Only 1 and 10 crops are supported, but got {}.".format(
args.test_crops))
data_loader = torch.utils.data.DataLoader(CoviarDataSet(
args.data_root,
args.flow_root,
args.data_name,
video_list=args.test_list,
num_segments=args.test_segments,
representation=args.representation,
new_length=args.new_length,
flow_ds_factor=args.flow_ds_factor,
upsample_interp=args.upsample_interp,
transform=cropping,
is_train=False,
accumulate=(not args.no_accumulation),
gop=args.gop,
flow_folder=args.data_flow,
viz=args.viz),
batch_size=1,
shuffle=False,
num_workers=args.workers * 2,
pin_memory=True)
# deploy model on gpu
if args.gpus is not None:
devices = [args.gpus[i] for i in range(args.workers)]
else:
devices = list(range(args.workers))
net.cuda(devices[0])
#net.base_model.cuda(devices[-1])
net = torch.nn.DataParallel(net, device_ids=devices)
# switch to inference model and start to iterate over the test set
net.eval()
total_num = len(data_loader.dataset)
output = []
# process each video to obtain its predictions
def forward_video(input_mv, input_residual, att=0):
input_mv_var = torch.autograd.Variable(input_mv, volatile=True)
input_residual_var = torch.autograd.Variable(input_residual,
volatile=True)
if att == 0:
scores, gen_flow = net(input_mv_var, input_residual_var)
if att == 1:
scores, gen_flow, att_flow = net(input_mv_var, input_residual_var)
scores = scores.view((-1, args.test_segments * args.test_crops) +
scores.size()[1:])
scores = torch.mean(scores, dim=1)
if att == 0:
return scores.data.cpu().numpy().copy(), gen_flow
if att == 1:
return scores.data.cpu().numpy().copy(), gen_flow, att_flow
proc_start_time = time.time()
# iterate over the whole test set
for i, (input_flow, input_mv, input_residual,
label) in enumerate(data_loader):
input_mv = input_mv.cuda(args.gpus[-1], async=True)
input_residual = input_residual.cuda(args.gpus[0], async=True)
input_flow = input_flow.cuda(args.gpus[-1], async=True)
# print("input_flow shape:")
# print(input_flow.shape) # torch.Size([batch_size, num_crops*num_segments, 2, 224, 224])
# print("input_flow type:") # print(input_flow.type()) # torch.cuda.FloatTensor
if args.att == 0:
video_scores, gen_flow = forward_video(input_mv, input_residual)
if args.att == 1:
video_scores, gen_flow, att_flow = forward_video(
input_mv, input_residual, args.att)
output.append((video_scores, label[0]))
cnt_time = time.time() - proc_start_time
if (i + 1) % 100 == 0:
print('video {} done, total {}/{}, average {} sec/video'.format(
i, i + 1, total_num,
float(cnt_time) / (i + 1)))
video_pred = [np.argmax(x[0]) for x in output]
video_labels = [x[1] for x in output]
print('Accuracy {:.02f}% ({})'.format(
float(np.sum(np.array(video_pred) == np.array(video_labels))) /
len(video_pred) * 100.0, len(video_pred)))
if args.save_scores is not None:
name_list = [x.strip().split()[0] for x in open(args.test_list)]
order_dict = {e: i for i, e in enumerate(sorted(name_list))}
reorder_output = [None] * len(output)
reorder_label = [None] * len(output)
reorder_name = [None] * len(output)
for i in range(len(output)):
idx = order_dict[name_list[i]]
reorder_output[idx] = output[i]
reorder_label[idx] = video_labels[i]
reorder_name[idx] = name_list[i]
np.savez(args.save_scores,
scores=reorder_output,
labels=reorder_label,
names=reorder_name)
def main():
writter = SummaryWriter('./log/test', comment='')
net = Model(2, args.num_segments, args.representation,
base_model=args.arch)
checkpoint = torch.load(args.weights)
# print("model epoch {} best prec@1: {}".format(checkpoint['epoch'], checkpoint['best_prec1']))
print("model epoch {} lowest loss {}".format(checkpoint['epoch'], checkpoint['loss_min']))
base_dict = {'.'.join(k.split('.')[1:]): v for k, v in list(checkpoint['state_dict'].items())}
net.load_state_dict(base_dict)
if args.test_crops == 1:
cropping = torchvision.transforms.Compose([
GroupScale(net.scale_size),
GroupCenterCrop(net.crop_size),
])
elif args.test_crops == 10:
cropping = torchvision.transforms.Compose([
GroupOverSample(net.crop_size, net.scale_size, is_mv=(args.representation == 'mv'))
])
else:
raise ValueError("Only 1 and 10 crops are supported, but got {}.".format(args.test_crops))
data_loader = torch.utils.data.DataLoader(
CoviarDataSet(
args.data_root,
video_list=args.test_list,
num_segments=args.num_segments,
representation=args.representation,
transform=cropping,
is_train=False,
accumulate=(not args.no_accumulation),
),
batch_size=1, shuffle=False,
num_workers=args.workers * 2, pin_memory=True)
devices = [torch.device("cuda:%d" % device) for device in args.gpus]
net = torch.nn.DataParallel(net.cuda(devices[0]), device_ids=devices)
net.eval()
total_num = len(data_loader.dataset)
scores = []
labels = []
proc_start_time = time.time()
correct_nums = 0
for i, (input_pairs, label) in enumerate(data_loader):
with torch.no_grad:
input_pairs[0] = input_pairs[0].float().to(devices[0])
input_pairs[1] = input_pairs[1].float().to(devices[0])
label = label.float().to(devices[0])
outputs, y = net(input_pairs)
_, predicts = torch.max(y, 1)
scores.append(y.detach().cpu().numpy())
labels.append(label.detach().cpu().numpy())
correct_nums += (predicts == label.clone().long()).sum()
cnt_time = time.time() - proc_start_time
if (i + 1) % 100 == 0:
print('video {} done, total {}/{}, average {} sec/video'.format(i, i + 1,
total_num,
float(cnt_time) / (i + 1)))
predits = np.argmax(scores, 1)
labels = np.around(labels).astype(np.long).ravel()
acc = 100 * correct_nums / len(data_loader.dataset)
target_names = ['Copy', 'Not Copy']
# writter.add_pr_curve('Precision/Recall', labels, predits)
writter.add_text('Accuracy', '%.3f%%' % acc)
writter.add_text(classification_report(labels, predits, target_names=target_names))
print(('Validating Results: accuracy: {accuracy:.3f}%'.format(accuracy=acc)))
if args.save_scores is not None:
with open(args.save_scores + '_scores.pkl', 'wb') as fp:
pickle.dump(scores, fp)
with open(args.save_scores + '_labels.pkl', 'wb') as fp:
pickle.dump(labels, fp)
def main():
# load trained model
'''
@Param
num_class: total number of classes
num_segments: number of TSN segments, test default = 25
representation: iframe, mv, residual
base_model: base architecture
'''
net = Model(num_class,
args.test_segments,
args.representation,
base_model=args.arch,
mv_stack_size=args.mv_stack_size)
# -----------------------------MODIFIED_CODE_START-------------------------------
# print(net)
# -----------------------------MODIFIED_CODE_END---------------------------------
# checkpoint trained model ? (not best model
checkpoint = torch.load(args.weights)
print("model epoch {} best prec@1: {}".format(checkpoint['epoch'],
checkpoint['best_prec1']))
base_dict = {
'.'.join(k.split('.')[1:]): v
for k, v in list(checkpoint['state_dict'].items())
}
net.load_state_dict(base_dict)
# -----------------------
# CLASS torchvision.transforms.Compose(transforms)[SOURCE]
# Composes several transforms together.
# Parameters: transforms (list of Transform objects) – list of transforms to compose.
# -----------------------
# -----------------------
# TSN:
# if args.test_crops == 1:
# cropping = torchvision.transforms.Compose([
# GroupScale(net.scale_size),
# GroupCenterCrop(net.input_size),
# ])
# -----------------------
if args.test_crops == 1:
cropping = torchvision.transforms.Compose([
GroupScale(net.scale_size),
GroupCenterCrop(net.crop_size),
])
# ??? what's difference between net.input_size and net.crop_size
# line 70 in model.py
# def crop_size(self):
# return self._input_size
# seems they are same here
# -----------------------
# TSN:
# elif args.test_crops == 10:
# cropping = torchvision.transforms.Compose([
# GroupOverSample(net.input_size, net.scale_size)
# ])
# -----------------------
# is_mv=(args.representation == 'mv') seems quite important
elif args.test_crops == 10:
cropping = torchvision.transforms.Compose([
GroupOverSample(net.crop_size,
net.scale_size,
is_mv=(args.representation == 'mv'))
])
# --test-crops specifies how many crops per segment.
# The value should be 1 or 10.
# 1 means using only one center crop.
# 10 means using 5 crops for both (horizontal) flips.
else:
raise ValueError(
"Only 1 and 10 crops are supported, but got {}.".format(
args.test_crops))
data_loader = torch.utils.data.DataLoader(
CoviarDataSet(
args.data_root,
args.data_name,
video_list=args.test_list,
num_segments=args.test_segments,
representation=args.representation,
transform=cropping, # seems important to stacking
# test_crops == 1: GroupScale + GroupCenterCrop
# the same as val_data_loader in train.py
# seems np.stack in resize_mv() called in GroupCenterCrop
# has the same effects as Stack() in TSN
# test_crops == 10: GroupOverSample
# -----------------------
# TSN:
# transform=torchvision.transforms.Compose([
# cropping,
# Stack(roll=args.arch == 'BNInception'), # this line seems important
# ToTorchFormatTensor(div=args.arch != 'BNInception'),
# GroupNormalize(net.input_mean, net.input_std),
# ])),
# -----------------------
is_train=False,
accumulate=(not args.no_accumulation),
mv_stack_size=args.mv_stack_size),
batch_size=1,
shuffle=False,
# -----------------------------ORIGINAL_CODE_START-----------------------------
# num_workers=args.workers * 2, pin_memory=True)
# -----------------------------ORIGINAL_CODE_END-------------------------------
# -----------------------------MODIFIED_CODE_START-----------------------------
num_workers=args.workers,
pin_memory=True)
# -----------------------------MODIFIED_CODE_END-------------------------------
if args.gpus is not None:
devices = [args.gpus[i] for i in range(args.workers)]
else:
devices = list(range(args.workers))
net = torch.nn.DataParallel(net.cuda(devices[0]), device_ids=devices)
net.eval()
data_gen = enumerate(data_loader)
total_num = len(data_loader.dataset)
output = []
def forward_video(data):
# torch.Size([batch_size, num_segment, 2*MV_STACK_SIZE, height, width])
# -----------------------------MODIFIED_CODE_START-------------------------------
# print("data.shape"+str(data.shape)) # testing: torch.Size([1, 25, 10, 224, 224])
# training: torch.Size([40, 3, 10, 224, 224])
# original:data.shape:torch.Size([1, 250, 2, 224, 224])
# so it seems that the format of input data in this function is not correct
# -----------------------------MODIFIED_CODE_END---------------------------------
input_var = torch.autograd.Variable(data, volatile=True)
# -----------------------------MODIFIED_CODE_START-------------------------------
# print("input_var:"+str(input_var.shape)) # input_var:torch.Size([1, 25, 10, 224, 224])
# original: input_var.shape:torch.Size([1, 250, 2, 224, 224])
# -----------------------------MODIFIED_CODE_END---------------------------------
# compute output
scores = net(input_var)
# -----------------------------MODIFIED_CODE_START-------------------------------
# torch.Size([batch_size*num_segment, num_class])
# print("scores: "+str(scores.shape)) # testing: torch.Size([25, 101])
# training: torch.Size([120, 101])
# print("scores.size()")
# print(scores.size()) # torch.Size([25, 101])
# -----------------------------MODIFIED_CODE_END---------------------------------
# what does args.test_segments * args.test_crops mean??
# view(*shape) → Tensor: Returns a new tensor with the same data as the self tensor but of a different shape.
# Parameters shape (torch.Size or int...) – the desired size
scores = scores.view((-1, args.test_segments * args.test_crops) +
scores.size()[1:])
scores = torch.mean(scores, dim=1)
return scores.data.cpu().numpy().copy()
proc_start_time = time.time()
for i, (data, label) in data_gen:
video_scores = forward_video(data)
output.append((video_scores, label[0]))
cnt_time = time.time() - proc_start_time
if (i + 1) % 100 == 0:
print('video {} done, total {}/{}, average {} sec/video'.format(
i, i + 1, total_num,
float(cnt_time) / (i + 1)))
video_pred = [np.argmax(x[0]) for x in output]
video_labels = [x[1] for x in output]
print('Accuracy {:.02f}% ({})'.format(
float(np.sum(np.array(video_pred) == np.array(video_labels))) /
len(video_pred) * 100.0, len(video_pred)))
if args.save_scores is not None:
name_list = [x.strip().split()[0] for x in open(args.test_list)]
order_dict = {e: i for i, e in enumerate(sorted(name_list))}
reorder_output = [None] * len(output)
reorder_label = [None] * len(output)
reorder_name = [None] * len(output)
for i in range(len(output)):
idx = order_dict[name_list[i]]
reorder_output[idx] = output[i]
reorder_label[idx] = video_labels[i]
reorder_name[idx] = name_list[i]
np.savez(args.save_scores,
scores=reorder_output,
labels=reorder_label,
names=reorder_name)
def main():
net = Model(num_class, base_model=args.arch)
checkpoint = torch.load(args.weights)
print("model epoch {} best prec@1: {}".format(checkpoint['epoch'],
checkpoint['best_prec1']))
base_dict = {
'.'.join(k.split('.')[1:]): v
for k, v in list(checkpoint['state_dict'].items())
}
net.load_state_dict(base_dict)
if args.test_crops == 1:
cropping = torchvision.transforms.Compose([
GroupScale(net.scale_size),
GroupCenterCrop(net.crop_size),
])
elif args.test_crops == 10:
cropping = torchvision.transforms.Compose([
GroupOverSample(net.crop_size,
net.scale_size,
is_mv=(args.representation == 'mv'))
])
else:
raise ValueError(
"Only 1 and 10 crops are supported, but got {}.".format(
args.test_crops))
data_loader = torch.utils.data.DataLoader(FoodDataSet(
args.data_root,
img_list=args.test_list,
transform=cropping,
is_train=False,
),
batch_size=1,
shuffle=False,
num_workers=args.workers * 2,
pin_memory=True)
if args.gpus is not None:
devices = [args.gpus[i] for i in range(args.workers)]
else:
devices = list(range(args.workers))
net = torch.nn.DataParallel(net.cuda(devices[0]), device_ids=devices)
net.eval()
data_gen = enumerate(data_loader)
total_num = len(data_loader.dataset)
output = []
def forward_img(data):
"""
Args:
data (Tensor): size [batch_size, c, h, w]
Returns:
scores (Tensor) : size [batch_size, num_class]
"""
with torch.no_grad():
input_var = torch.autograd.Variable(data, volatile=True)
scores = net(input_var)
scores = scores.view((-1, args.test_crops) + scores.size()[1:])
scores = torch.mean(scores, dim=1)
return scores.data.cpu().numpy().copy()
proc_start_time = time.time()
for i, (data, label) in data_gen:
# data = [1, c, h ,w], label = [1]
img_scores = forward_img(data)
output.append((img_scores[0], label[0]))
cnt_time = time.time() - proc_start_time
if (i + 1) % 100 == 0:
print('image {} done, total {}/{}, average {} sec/image'.format(
i, i + 1, total_num,
float(cnt_time) / (i + 1)))
img_pred = [np.argmax(x[0]) for x in output]
img_labels = [x[1] for x in output]
print('Accuracy {:.02f}% ({})'.format(
float(np.sum(np.array(img_pred) == np.array(img_labels))) /
len(img_pred) * 100.0, len(img_pred)))