一学就会！快来查收这份 MMPose 学习指南

class Hand():
    def __init__(self, model_path, joint_num=21, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):
        self.model_path = model_path
        self.joint_num = joint_num
        self.mean = np.array(mean).reshape(1, -1, 1, 1)
        self.std = np.array(std).reshape(1, -1, 1, 1)
        self.interpreter = MNN.Interpreter(model_path)
        self.model_sess = self.interpreter.createSession({
            'numThread': 1
        })
    def preprocess(self, img):
        input_shape = img.shape
        assert len(input_shape) == 4, 'expect shape like (1, C, H, W)'
        img = (np.transpose(img, (0, 3, 1, 2)) / 255. - self.mean) / self.std
        return img.astype(np.float32)
    def inference(self, img):
        input_shape = img.shape
        assert len(input_shape) == 4, 'expect shape like (1, C, H, W)'
        input_tensor = self.interpreter.getSessionInput(self.model_sess)
        tmp_input = MNN.Tensor(input_shape,
                               MNN.Halide_Type_Float,
                               img.astype(np.float32),
                               MNN.Tensor_DimensionType_Caffe)
        input_tensor.copyFrom(tmp_input)
        self.interpreter.runSession(self.model_sess)
        output_tensor = self.interpreter.getSessionOutputAll(self.model_sess)
        joint_coord = np.array(output_tensor['518'].getData())
        return joint_coord
    def predict(self, img):
        img = self.preprocess(img)
        joint_coord = self.inference(img)
        return joint_coord

# mmpose/apis/inference.py
    batch_data = []
    for bbox in bboxes:
        center, scale = _box2cs(cfg, bbox)
        # prepare data
        data = {
            'center':
            center,
            'scale':
            scale,
            'bbox_score':
            bbox[4] if len(bbox) == 5 else 1,
            'bbox_id':
            0,  # need to be assigned if batch_size > 1
            'dataset':
            dataset_name,
            'joints_3d':
            np.zeros((cfg.data_cfg.num_joints, 3), dtype=np.float32),
            'joints_3d_visible':
            np.zeros((cfg.data_cfg.num_joints, 3), dtype=np.float32),
            'rotation':
            0,
            'ann_info': {
                'image_size': np.array(cfg.data_cfg['image_size']),
                'num_joints': cfg.data_cfg['num_joints'],
                'flip_pairs': flip_pairs
            }
        }
        if isinstance(img_or_path, np.ndarray):
            data['img'] = img_or_path
        else:
            data['image_file'] = img_or_path
        data = test_pipeline(data)
        batch_data.append(data)
    batch_data = collate(batch_data, samples_per_gpu=len(batch_data))
    batch_data = scatter(batch_data, [device])[0]
    # forward the model
    with torch.no_grad():
        result = model(
            img=batch_data['img'],
            img_metas=batch_data['img_metas'],
            return_loss=False,
            return_heatmap=return_heatmap)
    return result['preds'], result['output_heatmap']

# /mmpose/models/detectors/top_down.py
@auto_fp16(apply_to=('img', ))
def forward(self,
            img,
            target=None,
            target_weight=None,
            img_metas=None,
            return_loss=True,
            return_heatmap=False,
            **kwargs):
    if return_loss:
        return self.forward_train(img, target, target_weight, img_metas,
                                      **kwargs)
    return self.forward_test(
        img, img_metas, return_heatmap=return_heatmap, **kwargs)

# /mmpose/models/detectors/top_down.py
def forward_test(self, img, img_metas, return_heatmap=False, **kwargs):
    """Defines the computation performed at every call when testing."""
    assert img.size(0) == len(img_metas)
    batch_size, _, img_height, img_width = img.shape
    if batch_size > 1:
        assert 'bbox_id' in img_metas[0]

    result = {}

    features = self.backbone(img)
    if self.with_neck:
        features = self.neck(features)
    if self.with_keypoint:
        output_heatmap = self.keypoint_head.inference_model(
            features, flip_pairs=None)

    if self.test_cfg.get('flip_test', True):
        img_flipped = img.flip(3)
        features_flipped = self.backbone(img_flipped)
        if self.with_neck:
            features_flipped = self.neck(features_flipped)
        if self.with_keypoint:
            output_flipped_heatmap = self.keypoint_head.inference_model(
                features_flipped, img_metas[0]['flip_pairs'])
            output_heatmap = (output_heatmap +
                              output_flipped_heatmap) * 0.5

    if self.with_keypoint:
        keypoint_result = self.keypoint_head.decode(
            img_metas, output_heatmap, img_size=[img_width, img_height])
        result.update(keypoint_result)

        if not return_heatmap:
            output_heatmap = None

        result['output_heatmap'] = output_heatmap

    return result

# /mmpose/models/heads/deeppose_regression_head.py
def decode(self, img_metas, output, **kwargs):
    batch_size = len(img_metas)
    if 'bbox_id' in img_metas[0]:
        bbox_ids = []
    else:
        bbox_ids = None
    c = np.zeros((batch_size, 2), dtype=np.float32)
    s = np.zeros((batch_size, 2), dtype=np.float32)
    image_paths = []
    score = np.ones(batch_size)
    for i in range(batch_size):
        c[i, :] = img_metas[i]['center']
        s[i, :] = img_metas[i]['scale']
        image_paths.append(img_metas[i]['image_file'])
        if 'bbox_score' in img_metas[i]:
            score[i] = np.array(img_metas[i]['bbox_score']).reshape(-1)
        if bbox_ids is not None:
            bbox_ids.append(img_metas[i]['bbox_id'])
    preds, maxvals = keypoints_from_regression(output, c, s,
                                                kwargs['img_size'])
    all_preds = np.zeros((batch_size, preds.shape[1], 3), dtype=np.float32)
    all_boxes = np.zeros((batch_size, 6), dtype=np.float32)
    all_preds[:, :, 0:2] = preds[:, :, 0:2]
    all_preds[:, :, 2:3] = maxvals
    all_boxes[:, 0:2] = c[:, 0:2]
    all_boxes[:, 2:4] = s[:, 0:2]
    all_boxes[:, 4] = np.prod(s * 200.0, axis=1)
    all_boxes[:, 5] = score
    result = {}
    result['preds'] = all_preds
    result['boxes'] = all_boxes
    result['image_paths'] = image_paths
    result['bbox_ids'] = bbox_ids
    return result

# /mmpose/core/evaluation/top_down_eval.py
def keypoints_from_regression(regression_preds, center, scale, img_size):
    N, K, _ = regression_preds.shape
    preds, maxvals = regression_preds, np.ones((N, K, 1), dtype=np.float32)
    preds = preds * img_size
    # Transform back to the image
    for i in range(N):
        preds[i] = transform_preds(preds[i], center[i], scale[i], img_size)
    return preds, maxvals
# /mmpose/core/post_processing/post_transforms.py
def transform_preds(coords, center, scale, output_size, use_udp=False):
    assert coords.shape[1] in (2, 4, 5)
    assert len(center) == 2
    assert len(scale) == 2
    assert len(output_size) == 2
    # Recover the scale which is normalized by a factor of 200.
    scale = scale * 200.0
    if use_udp:
        scale_x = scale[0] / (output_size[0] - 1.0)
        scale_y = scale[1] / (output_size[1] - 1.0)
    else:
        scale_x = scale[0] / output_size[0]
        scale_y = scale[1] / output_size[1]
    target_coords = np.ones_like(coords)
    target_coords[:, 0] = coords[:, 0] * scale_x + center[0] - scale[0] * 0.5
    target_coords[:, 1] = coords[:, 1] * scale_y + center[1] - scale[1] * 0.5
    return target_coords

# 加到Hand()里
def post_process(self, coords, bbox):
    w = bbox[2] - bbox[0]
    h = bbox[3] - bbox[1]
    target_coords = coords * np.array([w, h])
    target_coords += np.array([bbox[0], bbox[1]])
    return target_coords