def eval_model():
with TimerBlock("Good Luck") as block:
# params
args = parser_args.parser_args(block)
init_seed(1)
data_loader_train, data_loader_val = data_choose(args, block)
global_step, start_epoch, model, optimizer_dict = model_choose(args, block)
loss_function = loss_choose(args, block)
if type(args.device_id) is list and len(args.device_id) > 0:
model.cuda()
else:
pass
model.eval()
print('Validate')
loss, acc, score_dict, all_pre_true, wrong_path_pre_true = train_val_model.val_classifier(data_loader_val,
model,
loss_function, 0,
args,
None)
save_score = os.path.join(args.model_saved_name, 'score.pkl')
with open(save_score, 'wb') as f:
pickle.dump(score_dict, f)
with open(args.model_saved_name + '/all_pre_true.txt', 'w') as f:
f.writelines(all_pre_true)
with open(args.model_saved_name + '/wrong_path_pre_true.txt', 'w') as f:
f.writelines(wrong_path_pre_true)
print('Final: {}'.format(float(acc)))
def compare_samples(p_path, n_path, n_config):
p_negative_samples = open(p_path, 'r').readlines()
n_negative_samples = open(n_path, 'r').readlines()
labels = open('../prepare/ntu_60/label.txt', 'r').readlines()
for i in range(len(labels)):
labels[i] = labels[i].strip('\n')
p_neg_num = len(p_negative_samples)
n_neg_num = len(n_negative_samples)
p_id_dict = {}
n_id_dict = {}
p_pred = np.array([], dtype=np.int)
p_tgt = np.array([], dtype=np.int)
n_pred = np.array([], dtype=np.int)
n_tgt = np.array([], dtype=np.int)
for i in range(p_neg_num):
sample_line = p_negative_samples[i].strip('\n')
samples = sample_line.split(',')
p_id_dict[str(samples[0])] = i
p_pred_item = int(samples[1])
p_tgt_item = int(samples[2])
p_pred = np.append(p_pred, p_pred_item)
p_tgt = np.append(p_tgt, p_tgt_item)
for j in range(n_neg_num):
sample_line = n_negative_samples[j].strip('\n')
samples = sample_line.split(',')
n_id_dict[str(samples[0])] = j
n_pred_item = int(samples[1])
n_tgt_item = int(samples[2])
n_pred = np.append(n_pred, n_pred_item)
n_tgt = np.append(n_tgt, n_tgt_item)
good_samples = set(n_id_dict.keys()) - set(p_id_dict.keys())
bad_samples = set(p_id_dict.keys()) - set(n_id_dict.keys())
vid = list(good_samples)[0]
pred_label = labels[n_pred[n_id_dict[vid]]]
tgt_lable = labels[n_tgt[n_id_dict[vid]]]
# pred_label = labels[p_pred[p_id_dict[vid]]]
# tgt_lable = labels[p_tgt[p_id_dict[vid]]]
with TimerBlock("Good Luck") as block:
args = parser_args.parser_args(block, config_path=n_config)
edge_chose = args.data
if args.data == 'knitics':
is_3d = False
else:
is_3d = True
edge = edge_dict[edge_chose]
data_loader_train, data_loader_val = data_choose(args, block)
sample_name = data_loader_val.dataset.sample_name
sample_id = [name.split('.')[0] for name in sample_name]
index = sample_id.index(vid[:-9])
data = data_loader_val.dataset[index][0]
data = torch.tensor(data).unsqueeze(0)
tag = 'DSTA: ' + pred_label + '\n' + 'Ours:' + tgt_lable + '\n' + 'TGT:' + tgt_lable
vis_all(data=data.numpy(), edge=edge, is_3d=is_3d, tag=tag, pause=0.01)
print('ok')
def eval_vis_model(vid,
idx_shotcut=None,
config_path=None,
pause=0.01,
view=0.25):
import matplotlib.pyplot as plt
import matplotlib
with TimerBlock("Good Luck") as block:
args = parser_args.parser_args(block, config_path=config_path)
init_seed(1)
edge_chose = args.data
if args.data == 'knitics':
is_3d = False
else:
is_3d = True
edge = edge_dict[edge_chose]
data_loader_train, data_loader_val = data_choose(args, block)
# set_trace()
global_step, start_epoch, model, optimizer_dict = model_choose(
args, block)
lables = get_label()
if idx_shotcut is not None:
index = idx_shotcut
else:
sample_name = data_loader_val.dataset.sample_name
sample_id = [name.split('.')[0] for name in sample_name]
index = sample_id.index(vid)
data, label, index = data_loader_val.dataset[index]
tgt = lables[label]
if type(args.device_id) is list and len(args.device_id) > 0:
model.cuda()
else:
pass
model.eval()
data = torch.tensor(data).unsqueeze(0)
outputs, pretext_loss = model(data)
if len(outputs.data.shape) == 3: # T N cls
_, predict_label = torch.max(outputs.data[:, :, :-1].mean(0), 1)
else:
_, predict_label = torch.max(outputs.data, 1)
predict_label = predict_label.squeeze()
print('predict_label:', predict_label)
print('tgt:', label)
predict_label_tag = lables[predict_label]
tag = 'Pred: ' + predict_label_tag + '\n' + 'TGT:' + tgt
# vis_all(data=data.numpy(), edge=edge, is_3d=is_3d, tag=tag, pause=pause)
vis_all_color(data=data.numpy(),
edge=edge,
is_3d=is_3d,
tag=tag,
pause=pause)
print('Python %s on %s' % (sys.version, sys.platform))
sys.path.extend(['../'])
import pickle
from train_val_test import train_val_model, parser_args
from utility.log import TimerBlock, IteratorTimer
from method_choose.data_choose import data_choose, init_seed
from method_choose.model_choose import model_choose
from method_choose.loss_choose import loss_choose
with TimerBlock("Good Luck") as block:
# params
args = parser_args.parser_args(block)
init_seed(1)
data_loader_train, data_loader_val = data_choose(args, block)
global_step, start_epoch, model, optimizer_dict = model_choose(args, block)
loss_function = loss_choose(args, block)
model.cuda()
model.eval()
print('Validate')
loss, acc, score_dict, all_pre_true, wrong_path_pre_true = train_val_model.val_classifier(data_loader_val, model,
loss_function, 0, args,
None)
save_score = os.path.join(args.model_saved_name, 'score.pkl')
with open(save_score, 'wb') as f:
pickle.dump(score_dict, f)
with open(args.model_saved_name + '/all_pre_true.txt', 'w') as f:
f.writelines(all_pre_true)