def test_unpool(self):
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
input = SparseTensor(feats, coords)
conv = MinkowskiConvolution(
in_channels, out_channels, kernel_size=3, stride=2, dimension=D
)
conv = conv.double()
unpool = MinkowskiPoolingTranspose(kernel_size=3, stride=2, dimension=D)
input = conv(input)
output = unpool(input)
print(output)
# Check backward
fn = MinkowskiLocalPoolingTransposeFunction()
self.assertTrue(
gradcheck(
fn,
(
input.F,
unpool.pooling_mode,
unpool.kernel_generator,
input.coordinate_map_key,
None,
input.coordinate_manager,
),
)
)
def test(self):
print(f"{self.__class__.__name__}: test")
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
input = SparseTensor(feats, coords=coords)
# Initialize context
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
has_bias=True,
dimension=D)
conv = conv.double()
output = conv(input)
print(output)
kernel_map = input.coords_man.get_kernel_map(1,
2,
stride=2,
kernel_size=3)
print(kernel_map)
# Check backward
fn = MinkowskiConvolutionFunction()
self.assertTrue(
gradcheck(fn, (input.F, conv.kernel, input.tensor_stride,
conv.stride, conv.kernel_size, conv.dilation,
conv.region_type_, conv.region_offset_,
input.coords_key, None, input.coords_man)))
def test_unpool(self):
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
input = SparseTensor(feats, coords)
conv = MinkowskiConvolution(
in_channels, out_channels, kernel_size=3, stride=2, dimension=D
)
conv = conv.double()
unpool = MinkowskiPoolingTranspose(kernel_size=3, stride=2, dimension=D)
input = conv(input)
output = unpool(input)
print(output)
# Check backward
fn = MinkowskiPoolingTransposeFunction()
self.assertTrue(
gradcheck(
fn,
(
input.F,
input.tensor_stride,
unpool.stride,
unpool.kernel_size,
unpool.dilation,
unpool.region_type_,
unpool.region_offset_,
False,
input.coords_key,
None,
input.coords_man,
),
)
)
def test(self):
print(f"{self.__class__.__name__}: test_dense")
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
input = SparseTensor(feats, coords=coords)
# Initialize context
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
has_bias=True,
dimension=D)
conv = conv.double()
output = conv(input)
print(input.C, output.C)
# Convert to a dense tensor
dense_output, min_coord, tensor_stride = output.dense()
dense_output, min_coord, tensor_stride = output.dense(
min_coords=torch.IntTensor([-2, -2]),
max_coords=torch.IntTensor([4, 4]))
print(dense_output)
print(min_coord)
print(tensor_stride)
print(feats.grad)
loss = dense_output.sum()
loss.backward()
print(feats.grad)
def test(self):
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
input = SparseTensor(feats, coords=coords)
# Initialize context
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
has_bias=True,
dimension=D)
conv = conv.double()
conv_tr = MinkowskiConvolutionTranspose(out_channels,
in_channels,
kernel_size=2,
stride=2,
has_bias=True,
dimension=D)
conv_tr = conv_tr.double()
input = conv(input)
output = conv_tr(input)
print(output)
# Check backward
fn = MinkowskiConvolutionTransposeFunction()
self.assertTrue(
gradcheck(fn,
(input.F, conv_tr.kernel, input.tensor_stride,
conv_tr.stride, conv_tr.kernel_size, conv_tr.dilation,
conv_tr.region_type_, conv_tr.region_offset_,
input.coords_key, None, input.coords_man)))
def test_unpool_gpu(self):
if not torch.cuda.is_available():
return
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
input = SparseTensor(feats, coords)
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
dimension=D)
conv = conv.double()
unpool = MinkowskiPoolingTranspose(kernel_size=3,
stride=2,
dimension=D)
input = conv(input)
output = unpool(input)
print(output)
# Check backward
fn = MinkowskiLocalPoolingTransposeFunction()
self.assertTrue(
gradcheck(
fn,
(
input.F,
unpool.pooling_mode,
unpool.kernel_generator,
input.coordinate_map_key,
None,
input.coordinate_manager,
),
))
with torch.cuda.device(0):
conv = conv.to("cuda")
input = SparseTensor(feats, coords, device="cuda")
input = conv(input)
input.requires_grad_()
output = unpool(input)
print(output)
# Check backward
self.assertTrue(
gradcheck(
fn,
(
input.F,
unpool.pooling_mode,
unpool.kernel_generator,
input.coordinate_map_key,
None,
input.coordinate_manager,
),
))
def test(self):
print(f"{self.__class__.__name__}: test_dense")
in_channels, out_channels, D = 2, 3, 2
coords1 = torch.IntTensor([[0, 0], [0, 1], [1, 1]])
feats1 = torch.DoubleTensor([[1, 2], [3, 4], [5, 6]])
coords2 = torch.IntTensor([[1, 1], [1, 2], [2, 1]])
feats2 = torch.DoubleTensor([[7, 8], [9, 10], [11, 12]])
coords, feats = ME.utils.sparse_collate([coords1, coords2],
[feats1, feats2])
input = SparseTensor(feats, coords)
input.requires_grad_()
dinput, min_coord, tensor_stride = input.dense()
self.assertTrue(dinput[0, 0, 0, 1] == 3)
self.assertTrue(dinput[0, 1, 0, 1] == 4)
self.assertTrue(dinput[0, 0, 1, 1] == 5)
self.assertTrue(dinput[0, 1, 1, 1] == 6)
self.assertTrue(dinput[1, 0, 1, 1] == 7)
self.assertTrue(dinput[1, 1, 1, 1] == 8)
self.assertTrue(dinput[1, 0, 2, 1] == 11)
self.assertTrue(dinput[1, 1, 2, 1] == 12)
# Initialize context
conv = MinkowskiConvolution(
in_channels,
out_channels,
kernel_size=3,
stride=2,
bias=True,
dimension=D,
)
conv = conv.double()
output = conv(input)
print(input.C, output.C)
# Convert to a dense tensor
dense_output, min_coord, tensor_stride = output.dense()
print(dense_output.shape)
print(dense_output)
print(min_coord)
print(tensor_stride)
dense_output, min_coord, tensor_stride = output.dense(
min_coordinate=torch.IntTensor([-2, -2]))
print(dense_output)
print(min_coord)
print(tensor_stride)
print(feats.grad)
loss = dense_output.sum()
loss.backward()
print(feats.grad)
def test(self):
print(f"{self.__class__.__name__}: test")
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
input = SparseTensor(feats, coordinates=coords)
# Initialize context
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
bias=True,
dimension=D)
conv = conv.double()
output = conv(input)
print(output)
self.assertEqual(input.coordinate_map_key.get_tensor_stride(), [1, 1])
self.assertEqual(output.coordinate_map_key.get_tensor_stride(), [2, 2])
if torch.cuda.is_available():
input_gpu = SparseTensor(feats, coordinates=coords, device="cuda")
conv_gpu = conv.cuda()
output_gpu = conv_gpu(input_gpu)
self.assertTrue(
torch.allclose(output_gpu.F.var(0).cpu(), output.F.var(0)))
self.assertTrue(
torch.allclose(output_gpu.F.mean(0).cpu(), output.F.mean(0)))
# kernel_map = input.coords_man.kernel_map(
# 1, 2, stride=2, kernel_size=3)
# print(kernel_map)
# Check backward
fn = MinkowskiConvolutionFunction()
conv = conv.cpu()
self.assertTrue(
gradcheck(
fn,
(
input.F,
conv.kernel,
conv.kernel_generator,
conv.convolution_mode,
input.coordinate_map_key,
output.coordinate_map_key,
input.coordinate_manager,
),
))
for i in range(LEAK_TEST_ITER):
input = SparseTensor(feats, coordinates=coords)
conv(input).F.sum().backward()
def test_gpu(self):
print(f"{self.__class__.__name__}: test_gpu")
if not torch.cuda.is_available():
return
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
# Initialize context
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
bias=True,
dimension=D)
print(conv)
input = SparseTensor(feats, coordinates=coords)
conv = conv.double()
output = conv(input)
print(output)
device = torch.device("cuda")
input = SparseTensor(feats.to(device), coordinates=coords.to(device))
conv = conv.to(device)
output = conv(input)
print(output)
# Check backward
fn = MinkowskiConvolutionFunction()
grad = output.F.clone().zero_()
grad[0] = 1
output.F.backward(grad)
self.assertTrue(
gradcheck(
fn,
(
input.F,
conv.kernel,
conv.kernel_generator,
conv.convolution_mode,
input.coordinate_map_key,
None,
input.coordinate_manager,
),
))
def test_kernelmap(self):
print(f"{self.__class__.__name__}: test_kernelmap")
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
input = SparseTensor(feats, coords=coords)
# Initialize context
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
has_bias=True,
dimension=D)
conv = conv.double()
output = conv(input)
print(input.C, output.C)
print(output.coords_man.get_kernel_map(1, 2, stride=2, kernel_size=3))
def test_unpooling_gpu(self):
if not torch.cuda.is_available():
return
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
input = SparseTensor(feats, coords=coords)
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
dimension=D)
conv = conv.double()
unpool = MinkowskiPoolingTranspose(kernel_size=3,
stride=2,
dimension=D)
input = conv(input)
output = unpool(input)
print(output)
# Check backward
fn = MinkowskiPoolingTransposeFunction()
self.assertTrue(
gradcheck(fn, (input.F, input.tensor_stride, unpool.stride,
unpool.kernel_size, unpool.dilation,
unpool.region_type_, unpool.region_offset_, False,
input.coords_key, None, input.coords_man)))
device = torch.device('cuda')
with torch.cuda.device(0):
input = input.to(device)
output = unpool(input)
print(output)
# Check backward
fn = MinkowskiAvgPoolingFunction()
self.assertTrue(
gradcheck(fn, (input.F, input.tensor_stride, unpool.stride,
unpool.kernel_size, unpool.dilation,
unpool.region_type_, unpool.region_offset_, True,
input.coords_key, None, input.coords_man)))
def test_gpu(self):
print(f"{self.__class__.__name__}: test_gpu")
if not torch.cuda.is_available():
return
in_channels, out_channels, D = 2, 3, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
input = SparseTensor(feats, coords=coords)
# Initialize context
conv = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
has_bias=True,
dimension=D)
print(conv)
conv = conv.double()
output = conv(input)
print(output)
device = torch.device('cuda')
input = input.to(device)
conv = conv.to(device)
output = conv(input)
print(output)
print(output.F, output.coords)
# Check backward
fn = MinkowskiConvolutionFunction()
grad = output.F.clone().zero_()
grad[0] = 1
output.F.backward(grad)
self.assertTrue(
gradcheck(fn, (input.F, conv.kernel, input.tensor_stride,
conv.stride, conv.kernel_size, conv.dilation,
conv.region_type_, conv.region_offset_,
input.coords_key, None, input.coords_man)))