def main(conf, test_set, test_part=-1):
gulp_path = os.path.join(conf.gulp_test_dir, conf.modality.lower(), 'test',
test_set)
gulp_path = os.path.realpath(gulp_path)
gulp_path = Path(gulp_path)
classes_map = pickle.load(open(conf.classes_map, "rb"))
conf.num_classes = count_num_classes(classes_map)
net = TSN(conf.num_classes,
1,
conf.modality,
base_model=conf.arch,
consensus_type=conf.crop_fusion_type,
dropout=conf.dropout)
checkpoint = torch.load(conf.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 conf.test_crops == 1:
cropping = torchvision.transforms.Compose([
GroupScale(net.scale_size),
GroupCenterCrop(net.input_size),
])
elif conf.test_crops == 10:
cropping = torchvision.transforms.Compose(
[GroupOverSample(net.input_size, net.scale_size)])
else:
raise ValueError(
"Only 1 and 10 crops are supported while we got {}".format(
conf.test_crops))
class_type = 'verb+noun' if conf.class_type == 'action' else conf.class_type
if conf.modality == 'Flow':
dataset = EpicVideoFlowDataset(gulp_path=gulp_path,
class_type=class_type)
else:
dataset = EpicVideoDataset(gulp_path=gulp_path, class_type=class_type)
data_loader = torch.utils.data.DataLoader(EpicTSNTestDataset(
dataset,
classes_map,
num_segments=conf.test_segments,
new_length=1 if conf.modality == "RGB" else 5,
modality=conf.modality,
transform=torchvision.transforms.Compose([
cropping,
Stack(roll=conf.arch == 'BNInception'),
ToTorchFormatTensor(div=conf.arch != 'BNInception'),
GroupNormalize(net.input_mean, net.input_std),
]),
part=test_part),
batch_size=1,
shuffle=False,
num_workers=conf.workers * 2,
pin_memory=True)
net = torch.nn.DataParallel(net, device_ids=conf.gpus).cuda()
net.eval()
total_num = len(data_loader.dataset)
output = []
proc_start_time = time.time()
for i, (keys, input_) in enumerate(data_loader):
rst = eval_video(conf, (i, keys, input_), net)
output.append(rst[1:])
cnt_time = time.time() - proc_start_time
print('video {} done, total {}/{}, average {} sec/video'.format(
i, i + 1, total_num,
float(cnt_time) / (i + 1)))
video_index = [x[0] for x in output]
scores = [x[1] for x in output]
save_scores = './{}/tsn_{}_{}_testset_{}_{}_lr_{}_model_{:03d}.npz'.format(
conf.checkpoint, conf.class_type, conf.modality.lower(), test_set,
conf.arch, conf.lr, checkpoint['epoch'])
if test_part > 0:
save_scores = save_scores.replace('.npz',
'_part-{}.npz'.format(test_part))
np.savez(save_scores, segment_indices=video_index, scores=scores)
# Define the transform
batch_size = 1
snippet_length = 1 # Number of frames composing the snippet, 1 for RGB, 5 for optical flow
snippet_channels = 3 # Number of channels in a frame, 3 for RGB, 2 for optical flow
height, width = 224, 224
crop_count = 10
if crop_count == 1:
cropping = Compose([
GroupScale(model.scale_size),
GroupCenterCrop(model.input_size),
])
elif crop_count == 10:
cropping = GroupOverSample(model.input_size, model.scale_size)
else:
raise ValueError("Only 1 and 10 crop_count are supported while we got {}".format(crop_count))
transform = Compose([
cropping,
Stack(roll=base_model == base_model),
ToTorchFormatTensor(div=base_model != base_model),
GroupNormalize(model.input_mean, model.input_std),
])
pred_verb_indices = []
pred_noun_indices = []
pred_verb_classes = []
pred_noun_classes = []
gt_verb_indices = []
def main():
parser = argparse.ArgumentParser(
description="Action Recognition with Coviar (CVPR2018)")
parser.add_argument('--video-name', type=str, default=None)
parser.add_argument('--orig-video', type=str, default=None)
parser.add_argument('--num-class', type=int, default=5)
parser.add_argument('--num-segments', type=int, default=3)
parser.add_argument('--representation',
type=str,
choices=['iframe', 'mv', 'residual'],
default=None)
parser.add_argument('--arch', type=str, default=None)
parser.add_argument('--model', type=str, default=None)
parser.add_argument(
'--no-accumulation',
action='store_true',
help='disable accumulation of motion vectors and residuals.')
args = parser.parse_args()
#載入model
net = Model(args.num_class,
args.num_segments,
args.representation,
base_model=args.arch)
checkpoint = torch.load(args.model)
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)
#data argumentaion預設每個segment產生10個
cropping = torchvision.transforms.Compose([
GroupOverSample(net.crop_size,
net.scale_size,
is_mv=(args.representation == 'mv'))
])
#我們只有一個GPU, 所以只能設cudo(0) => GPU0
devices = [0]
net = torch.nn.DataParallel(net.cuda(devices[0]), device_ids=devices)
net.eval()
#姿態辨識
result, scores = actionRecongnize(args, net, cropping)
np.savez(args.representation + "_recognizer_score.npz",
scores=np.array(scores),
labels=np.array(result))
#print(len(result))
#讀檔
cap = cv2.VideoCapture(args.orig_video)
if cap.isOpened() is False:
print('Error opening video stream or file')
return
frame_num = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
copy_list = cal_complementary_frames(frame_num, 1500)
action_list = cal_complementary_segments(result, 38)
#寫檔
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('./result.avi', fourcc, 30.0, (1920, 1080))
#產生影片
frame_cnt = 0
frame = np.array([])
for i in range(len(copy_list)):
#
if not copy_list[i]:
_, frame = cap.read()
#
else:
#當實際幀數比預期幀數多的時候,透過平均跳過的方式把多的幀數丟掉
if frame_num > 1500:
_, frame = cap.read()
_, frame = cap.read()
#
if action_list[(i // SEG_SIZE)] == 1:
cv2.putText(frame, "WritingOnBoard", (10, 50),
cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 2)
else:
cv2.putText(frame, "Non-WritingOnBoard", (10, 50),
cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2)
#
out.write(frame)
frame_cnt += 1
print('\rcurrent/total frame = {}/{} / Progress: {:.1f}%'.format(
frame_cnt, frame_num, (frame_cnt / frame_num) * 100),
end='')
sys.stdout.flush()
out.release()
cap.release()
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():
# 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():
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():
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)))