search

NVIDIA / MinkowskiEngine

Minkowski Engine is an auto-diff neural network library for high-dimensional sparse tensors
https://nvidia.github.io/MinkowskiEngine
Other
2.43k stars 360 forks source link

I think this may be a bug. B.coordinate_map_key isn't equal to AAA.coordinate_map_key #598

Open hjmnbnb opened 3 months ago

hjmnbnb commented 3 months ago 
    A = ME.SparseTensor(                                                                                                                                                                                                                                                              
            features=torch.FloatTensor([                                                                                                                                                                                                                                              
                [1],                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                [1]                                                                                                                                                                                                                                                                
            ]),                                                                                                                                                                                                                                                                       
            coordinates=torch.IntTensor([                                                                                                                                                                                                                                             
                [0, 0, 4],                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                [0, 4, 0]                                                                                                                                                                                                                                                          
            ]),                                                                                                                                                                                                                                                                       
            device=device,
            tensor_stride=4
            )
    AA = ME.SparseTensor(                                                                                                                                                                                                                                                              
            features=torch.FloatTensor([                                                                                                                                                                                                                                              
                [1],                                                                                                                                                                                                                                                               
                [1],                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           
                [1]                                                                                                                                                                                                                                                                
            ]),                                                                                                                                                                                                                                                                       
            coordinates=torch.IntTensor([                                                                                                                                                                                                                                             
                [0, 0, 4],                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                [0, 4, 0],                                                                                                                                                                                                                                                         
                [0, 4, 0]                                                                                                                                                                                                                                                          
            ]),                                                                                                                                                                                                                                                                       
            device=device,
            tensor_stride=4,
            coordinate_manager=A.coordinate_manager
            )
    convtr_1 = ME.MinkowskiConvolutionTranspose(in_channels=1,                                                                                                                                                                                                                
                                                        out_channels=1,                                                                                                                                                                                                               
                                                        kernel_size=2,                                                                                                                                                                                                                
                                                        stride=1,                                                                                                                                                                                                                     
                                                        bias=False,                                                                                                                                                                                                                   
                                                        dimension=A.dimension).to(device)   
    print(A.coordinate_map_key) #coordinate map key:[4, 4]
    AAA=A+AA
    print(AAA.coordinate_map_key) #coordinate map key:[4, 4]:merge-ncCHr
    B = convtr_1(AAA)
    print(B.coordinate_map_key)   #coordinate map key:[4, 4]