def __init__(self, config, device='cuda:0'):
        super().__init__()

        self.num_joints = config.model.backbone.num_joints
        self.volume_aggregation_method = config.model.volume_aggregation_method

        # volume
        self.volume_softmax = config.model.volume_softmax
        self.volume_multiplier = config.model.volume_multiplier
        self.volume_size = config.model.volume_size

        self.cuboid_side = config.model.cuboid_side

        self.kind = config.model.kind

        # heatmap
        self.heatmap_softmax = config.model.heatmap_softmax
        self.heatmap_multiplier = config.model.heatmap_multiplier

        # modules
        config.model.backbone.alg_confidences = False
        config.model.backbone.vol_confidences = False

        self.backbone = pose_resnet.get_pose_net(config.model.backbone,
                                                 device=device)

        for p in self.backbone.final_layer.parameters():
            p.requires_grad = False

        self.process_features = nn.Sequential(nn.Conv2d(256, 32, 1))

        self.volume_net = V2VModel(32, self.num_joints)

        self.inputImageShape = [384, 384]
        self.outputHeatmapShape = [96, 96]
Пример #2
0
    def __init__(self, config):
        super().__init__()

        config.model.backbone.alg_confidences = False
        config.model.backbone.vol_confidences = False
        self.backbone = pose_resnet.get_pose_net(config.model.backbone)
        # self.return_confidences = config.backbone.return_confidences
        self.direct_optimization = config.model.direct_optimization
    def __init__(self, config, device='cuda:0'):
        super().__init__()

        config.model.backbone.alg_confidences = False
        config.model.backbone.vol_confidences = False
        self.backbone = pose_resnet.get_pose_net(config.model.backbone,
                                                 device=device)

        self.direct_optimization = config.model.direct_optimization
    def __init__(self, config, device='cuda:0'):
        super().__init__()

        self.use_confidences = config.model.use_confidences

        if config.model.use_default_backbone:
            self.backbone = pose_resnet.get_pose_net(config.model.backbone,
                                                     config.opt.batch_size,
                                                     device=device)
        else:
            self.backbone = pose_hrnet.get_pose_net(device=device)

        self.heatmap_softmax = config.model.heatmap_softmax
        self.heatmap_multiplier = config.model.heatmap_multiplier
Пример #5
0
    def __init__(self, config):
        super().__init__()

        self.use_confidences = config.model.use_confidences

        config.model.backbone.alg_confidences = False
        config.model.backbone.vol_confidences = False

        if self.use_confidences:
            config.model.backbone.alg_confidences = True

        self.backbone = pose_resnet.get_pose_net(config.model.backbone)

        self.heatmap_softmax = config.model.heatmap_softmax  # true
        self.heatmap_multiplier = config.model.heatmap_multiplier
Пример #6
0
    def __init__(self, config, device='cuda:0'):
        super().__init__()

        self.num_joints = config.model.backbone.num_joints
        self.volume_aggregation_method = config.model.volume_net.volume_aggregation_method

        # volume
        self.volume_softmax = config.model.volume_net.volume_softmax
        self.volume_multiplier = config.model.volume_net.volume_multiplier
        self.volume_size = config.model.volume_net.volume_size

        self.cuboid_size = config.model.volume_net.cuboid_size

        self.kind = config.model.kind
        self.use_gt_pelvis = config.model.volume_net.use_gt_pelvis

        # heatmap
        self.heatmap_softmax = config.model.heatmap_softmax
        self.heatmap_multiplier = config.model.heatmap_multiplier

        # transfer
        self.transfer_cmu_to_human36m = config.dataset.transfer_cmu_to_human36m

        # modules
        config.model.backbone.alg_confidences = False
        config.model.backbone.vol_confidences = False
        if self.volume_aggregation_method.startswith('conf'):
            config.model.backbone.vol_confidences = True

        self.backbone = pose_resnet.get_pose_net(config.model.backbone)
        self.use_feature = config.model.volume_net.use_feature_v2v


        if config.model.backbone.fix_weights:
            for p in self.backbone.parameters():
                p.requires_grad = False
        elif self.use_feature:
            for p in self.backbone.final_layer.parameters():
                p.requires_grad = False

        v2v_in_channel = self.num_joints
        if self.use_feature:
            self.process_features = nn.Sequential(
                nn.Conv2d(256, 32, 1)
            )
            v2v_in_channel = 32

        self.volume_net = V2VNet(v2v_in_channel, self.num_joints, config)
    def __init__(self, config, device='cuda:0'):
        super().__init__()

        self.num_joints = config.model.backbone.num_joints
        self.volume_aggregation_method = config.model.volume_aggregation_method

        # volume
        self.volume_softmax = config.model.volume_softmax
        self.volume_multiplier = config.model.volume_multiplier
        self.volume_size = config.model.volume_size

        self.cuboid_side = config.model.cuboid_side

        self.kind = config.model.kind
        self.use_gt_pelvis = config.model.use_gt_pelvis

        # heatmap
        self.heatmap_softmax = config.model.heatmap_softmax
        self.heatmap_multiplier = config.model.heatmap_multiplier

        # transfer
        self.transfer_cmu_to_human36m = config.model.transfer_cmu_to_human36m if hasattr(
            config.model, "transfer_cmu_to_human36m") else False

        # modules
        config.model.backbone.alg_confidences = False
        config.model.backbone.vol_confidences = False
        if self.volume_aggregation_method.startswith('conf'):
            config.model.backbone.vol_confidences = True

        self.backbone = pose_resnet.get_pose_net(config.model.backbone,
                                                 config.opt.batch_size,
                                                 device=device)

        for p in self.backbone.final_layer.parameters():
            p.requires_grad = False

        self.process_features = nn.Sequential(nn.Conv2d(256, 32, 1))

        self.volume_net = V2VModel(32, self.num_joints)
    def __init__(self, config, device='cpu'):
        super().__init__()

        self.num_joints = 17
        self.volume_aggregation_method = "softmax"

        # volume
        self.volume_softmax = True
        self.volume_multiplier = 1.0
        self.volume_size = 64

        self.cuboid_side = 2500.0

        self.kind = "mpii"
        self.use_gt_pelvis = False

        # heatmap
        self.heatmap_softmax = True
        self.heatmap_multiplier = 1.0

        # transfer
        self.transfer_cmu_to_human36m = False

        # modules
        config.model.backbone.alg_confidences = False
        config.model.backbone.vol_confidences = False
        if self.volume_aggregation_method.startswith('conf'):
            config.model.backbone.vol_confidences = True

        self.backbone = pose_resnet.get_pose_net(config.model.backbone,
                                                 device=device)

        for p in self.backbone.final_layer.parameters():
            p.requires_grad = False

        self.process_features = nn.Sequential(nn.Conv2d(256, 32, 1))

        self.volume_net = V2VModel(32, self.num_joints)