def test_kernel_map(self):
print(f"{self.__class__.__name__}: test_gpu")
if not torch.cuda.is_available():
return
in_channels, out_channels, D = 2, 2, 2
coords, feats, labels = data_loader(in_channels)
feats = feats.double()
feats.requires_grad_()
# Initialize context
conv1 = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=2,
stride=2,
bias=True,
dimension=D).double()
conv2 = MinkowskiConvolution(in_channels,
out_channels,
kernel_size=3,
stride=2,
bias=True,
dimension=D).double()
device = torch.device("cuda")
input = SparseTensor(
feats,
coordinates=coords,
device=device,
minkowski_algorithm=MinkowskiAlgorithm.SPEED_OPTIMIZED,
)
print(input)
conv1 = conv1.to(device)
conv2 = conv2.to(device)
output = conv2(conv1(input))
print(output)
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_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_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)))
def test_expansion(self):
print(f"{self.__class__.__name__}: test_expansion")
in_channels, out_channels, D = 2, 2, 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=False,
expand_coordinates=True,
dimension=D,
).double()
input = SparseTensor(
feats,
coordinates=coords,
minkowski_algorithm=MinkowskiAlgorithm.SPEED_OPTIMIZED,
)
print(input)
output = conv(input)
print(output)
if not torch.cuda.is_available():
return
input = SparseTensor(
feats,
coordinates=coords,
minkowski_algorithm=MinkowskiAlgorithm.SPEED_OPTIMIZED,
device="cuda",
)
conv = conv.to("cuda")
print(input)
output = conv(input)
print(output)