コード例 #1
0
ファイル: gpnet.py プロジェクト: ZhihaoAIRobotic/GPNet
 def __init__(self, input_dim=128, point_num=50, bn=True):
     super(AntipodalPredictBatch, self).__init__()
     self.input_dim = input_dim
     # self.conv1 = nn.Conv2d(input_dim, 512, 1)
     # self.max_pool = nn.MaxPool2d((1, point_num), stride=(1, 1))
     # self.mean_pool = nn.AvgPool2d((1, point_num), stride=(1, 1))
     self.weighted_mean = pt_utils.Conv2d(input_dim, input_dim, kernel_size=(1, point_num), padding=0, bn=bn)
     self.conv1 = pt_utils.Conv1d(input_dim, 512, 1, bn=bn)
     self.score = nn.Sequential(pt_utils.Conv1d(512, 256, 1, bn=bn), pt_utils.Conv1d(256, 1, 1, activation=None))
     self.sigmoid = nn.Sigmoid()
コード例 #2
0
ファイル: gpnet.py プロジェクト: ZhihaoAIRobotic/GPNet
 def __init__(self, input_dim=128, point_num=50, bn=True, tanh=False):
     super(PosePredictBatch, self).__init__()
     self.input_dim = input_dim
     # self.conv1 = nn.Conv2d(input_dim, 512, 1)
     self.max_pool = nn.MaxPool2d((1, point_num), stride=(1, 1))
     self.mean_pool = nn.AvgPool2d((1, point_num), stride=(1, 1))
     self.weighted_mean = pt_utils.Conv2d(input_dim, input_dim, kernel_size=(1, point_num), padding=0, bn=bn)
     self.conv1 = pt_utils.Conv1d(input_dim, 512, 1, bn=bn)
     self.score = nn.Sequential(pt_utils.Conv1d(512, 256, 1, bn=bn), pt_utils.Conv1d(256, 1, 1, activation=None))
     self.offset = nn.Sequential(pt_utils.Conv1d(512, 256, 1, bn=bn), pt_utils.Conv1d(256, 3, 1, activation=None))
     self.angle = nn.Sequential(pt_utils.Conv1d(512, 256, 1, bn=bn), pt_utils.Conv1d(256, 1, 1, activation=None))
     self.sigmoid = nn.Sigmoid()
     self.use_tanh = tanh
     self.tanh = nn.Tanh()
コード例 #3
0
ファイル: gpnet.py プロジェクト: ZhihaoAIRobotic/GPNet
 def __init__(self, in_dim=3, out_dim=128, bn=True):
     super(GridFeat, self).__init__()
     self.out_dim = out_dim
     self.layers = nn.Sequential(pt_utils.Conv1d(in_dim, 64, 1, bn=bn), pt_utils.Conv1d(64, out_dim, 1, bn=bn))
コード例 #4
0
ファイル: gpnet.py プロジェクト: ZhihaoAIRobotic/GPNet
    def __init__(self, input_channels=0, use_xyz=True, bn=True):
        super(PointNetFeat, self).__init__()
        
        self.SA_modules = nn.ModuleList()
        c_in = input_channels
        # print(c_in)
        self.SA_modules.append(
            PointnetSAModuleMSG(
                npoint=1024,
                radii=[0.05, 0.1],
                nsamples=[16, 32],
                mlps=[[c_in, 16, 16, 32], [c_in, 32, 32, 64]],
                use_xyz=True,
                bn=bn
            )
        )
        c_out_0 = 32 + 64

        c_in = c_out_0
        self.SA_modules.append(
            PointnetSAModuleMSG(
                npoint=256,
                radii=[0.1, 0.2],
                nsamples=[16, 32],
                mlps=[[c_in, 64, 64, 128], [c_in, 64, 96, 128]],
                use_xyz=use_xyz,
                bn=bn
            )
        )
        c_out_1 = 128 + 128

        c_in = c_out_1
        self.SA_modules.append(
            PointnetSAModuleMSG(
                npoint=64,
                radii=[0.2, 0.4],
                nsamples=[16, 32],
                mlps=[[c_in, 128, 196, 256], [c_in, 128, 196, 256]],
                use_xyz=use_xyz,
                bn=bn
            )
        )
        c_out_2 = 256 + 256

        c_in = c_out_2
        self.SA_modules.append(
            PointnetSAModuleMSG(
                npoint=16,
                radii=[0.4, 0.8],
                nsamples=[16, 32],
                mlps=[[c_in, 256, 256, 512], [c_in, 256, 384, 512]],
                use_xyz=use_xyz,
                bn=bn
            )
        )
        c_out_3 = 512 + 512

        self.FP_modules = nn.ModuleList()
        self.FP_modules.append(
            PointnetFPModule(mlp=[256 + input_channels, 128, 128], bn=bn)
        )
        self.FP_modules.append(PointnetFPModule(mlp=[512 + c_out_0, 256, 256], bn=bn))
        self.FP_modules.append(PointnetFPModule(mlp=[512 + c_out_1, 512, 512], bn=bn))
        self.FP_modules.append(
            PointnetFPModule(mlp=[c_out_3 + c_out_2, 512, 512], bn=bn)
        )

        self.FC_layer = nn.Sequential(
            pt_utils.Conv1d(128, 128, bn=bn)
        )
        self.sigmoid = nn.Sigmoid()