def predict_on_frames(args):
# Load model
mesh = Mesh(device=device)
# Our pretrained networks have 5 residual blocks with 256 channels.
# You might want to change this if you use a different architecture.
model = CMR(mesh, 5, 256, pretrained_checkpoint=args.checkpoint, device=device)
model.to(device)
model.eval()
image_paths = [os.path.join(args.in_folder, f) for f in sorted(os.listdir(args.in_folder))
if f.endswith('.png')]
print('Predicting on all png images in {}'.format(args.in_folder))
all_vertices = []
all_vertices_smpl = []
all_cams = []
for image_path in image_paths:
print("Image: ", image_path)
# Preprocess input image and generate predictions
img, norm_img = process_image(image_path, input_res=cfg.INPUT_RES)
norm_img = norm_img.to(device)
with torch.no_grad():
pred_vertices, pred_vertices_smpl, pred_camera, _, _ = model(norm_img)
pred_vertices = pred_vertices.cpu().numpy()
pred_vertices_smpl = pred_vertices_smpl.cpu().numpy()
pred_camera = pred_camera.cpu().numpy()
all_vertices.append(pred_vertices)
all_vertices_smpl.append(pred_vertices_smpl)
all_cams.append(pred_camera)
# Save predictions as pkl
all_vertices = np.concatenate(all_vertices, axis=0)
all_vertices_smpl = np.concatenate(all_vertices_smpl, axis=0)
all_cams = np.concatenate(all_cams, axis=0)
pred_dict = {'verts': all_vertices,
'verts_smpl': all_vertices_smpl,
'pred_cam': all_cams}
if args.out_folder == 'dataset':
out_folder = args.in_folder.replace('cropped_frames', 'cmr_results')
else:
out_folder = args.out_folder
print('Saving to', os.path.join(out_folder, 'cmr_results.pkl'))
os.makedirs(out_folder)
for key in pred_dict.keys():
print(pred_dict[key].shape)
with open(os.path.join(out_folder, 'cmr_results.pkl'), 'wb') as f:
pickle.dump(pred_dict, f)
parser.add_argument('--checkpoint', default=None, help='Path to network checkpoint')
parser.add_argument('--gpu', default='0', type=str)
parser.add_argument('--num_workers', default=4, type=int, help='Number of processes for data loading')
parser.add_argument('--path_correction', action='store_true')
args = parser.parse_args()
# Device
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
# Load model
mesh = Mesh(device=device)
# Our pretrained networks have 5 residual blocks with 256 channels.
# You might want to change this if you use a different architecture.
model = CMR(mesh, 5, 256, pretrained_checkpoint=args.checkpoint, device=device)
model.to(device)
model.eval()
# Setup evaluation dataset
dataset_path = '/scratch/as2562/datasets/sports_videos_smpl/final_dataset'
dataset = SportsVideosEvalDataset(dataset_path, img_wh=config.INPUT_RES,
path_correction=args.path_correction)
print("Eval examples found:", len(dataset))
# Metrics
metrics = ['pve', 'pve_scale_corrected', 'pve_pa', 'pve-t', 'pve-t_scale_corrected',
'silhouette_iou', 'j2d_l2e']
save_path = '/data/cvfs/as2562/GraphCMR/evaluations/sports_videos_final_dataset'
if not os.path.exists(save_path):
print('Accuracy: ', accuracy / pixel_count)
print('F1: ', f1.mean())
print()
if eval_parts:
print('Parts Accuracy: ', parts_accuracy / parts_pixel_count)
print('Parts F1 (BG): ', parts_f1[[0, 1, 2, 3, 4, 5, 6]].mean())
print()
if __name__ == '__main__':
args = parser.parse_args()
with open(args.config, 'r') as f:
options = json.load(f)
options = namedtuple('options', options.keys())(**options)
# Load model
mesh = Mesh()
model = CMR(mesh,
options.num_layers,
options.num_channels,
pretrained_checkpoint=args.checkpoint)
# Setup evaluation dataset
dataset = BaseDataset(options, args.dataset, is_train=False)
# Run evaluation
run_evaluation(model,
args.dataset,
dataset,
mesh,
batch_size=args.batch_size,
shuffle=args.shuffle,
log_freq=args.log_freq)
elif openpose_file is not None:
center, scale = bbox_from_openpose(openpose_file)
img = crop(img, center, scale, (input_res, input_res))
img = img.astype(np.float32) / 255.
img = torch.from_numpy(img).permute(2,0,1)
norm_img = normalize_img(img.clone())[None]
return img, norm_img
if __name__ == '__main__':
args = parser.parse_args()
# Load model
mesh = Mesh()
# Our pretrained networks have 5 residual blocks with 256 channels.
# You might want to change this if you use a different architecture.
model = CMR(mesh, 5, 256, pretrained_checkpoint=args.checkpoint)
model.cuda()
model.eval()
# Setup renderer for visualization
renderer = Renderer()
# Preprocess input image and generate predictions
img, norm_img = process_image(args.img, args.bbox, args.openpose, input_res=cfg.INPUT_RES)
with torch.no_grad():
pred_vertices, pred_vertices_smpl, pred_camera, _, _ = model(norm_img.cuda())
# Calculate camera parameters for rendering
camera_translation = torch.stack([pred_camera[:,1], pred_camera[:,2],
2*cfg.FOCAL_LENGTH/(cfg.INPUT_RES * pred_camera[:,0] +1e-9)],dim=-1)
camera_translation = camera_translation[0].cpu().numpy()
args.crop_setting, 'keypoints.pkl')
log_dir = os.path.join(cfg.BASE_DATA_DIR, 'cmr_pck_results.txt')
with open(gt_kp_path, 'rb') as f:
gt = pkl.load(f)
calc = CalcPCK(
all_kps,
gt,
num_imgs=cfg.DATASET_SIZES[args.dataset][args.crop_setting],
log_dir=log_dir,
dataset=args.dataset,
crop_setting=args.crop_setting,
pck_eval_threshold=args.pck_eval_threshold)
calc.eval()
if __name__ == '__main__':
args = parser.parse_args()
# Load model
mesh = Mesh()
model = CMR(mesh,
args.num_layers,
args.num_channels,
pretrained_checkpoint=args.pretrained_checkpoint)
# Setup evaluation dataset
dataset = BaseDataset(args, args.dataset)
# Run evaluation
run_evaluation(model, args, dataset, mesh)