Relating the PointNet++ classification model to the original paper architecture description.

[DanielTakeshi]

Hello!

Thank you so much for this great resource. I have been looking at the PointNet++ implementation here:

https://github.com/pyg-team/pytorch_geometric/blob/master/examples/pointnet2_classification.py
https://github.com/pyg-team/pytorch_geometric/blob/master/examples/pointnet2_segmentation.py

as well as the Google Colab tutorial: #141

I now feel much more comfortable understanding PointNet++.

---

Right now I'm trying to figure out how the description from the NeurIPS 2017 paper (https://arxiv.org/abs/1706.02413) translates into the PyTorch code. For simplicity, let's just consider the classification version of PointNet++, and in the code it is here:

pytorch_geometric/examples/pointnet2_classification.py

Lines 43 to 61 in 50b7bfc

	class Net(torch.nn.Module):
	def __init__(self):
	super().__init__()
	# Input channels account for both `pos` and node features.
	self.sa1_module = SAModule(0.5, 0.2, MLP([3, 64, 64, 128]))
	self.sa2_module = SAModule(0.25, 0.4, MLP([128 + 3, 128, 128, 256]))
	self.sa3_module = GlobalSAModule(MLP([256 + 3, 256, 512, 1024]))
	self.mlp = MLP([1024, 512, 256, 10], dropout=0.5, batch_norm=False)
	def forward(self, data):
	sa0_out = (data.x, data.pos, data.batch)
	sa1_out = self.sa1_module(*sa0_out)
	sa2_out = self.sa2_module(*sa1_out)
	sa3_out = self.sa3_module(*sa2_out)
	x, pos, batch = sa3_out
	return self.mlp(x).log_softmax(dim=-1)

The paper's appendix says this regarding the classification architecture:

From the paper, it says that the notation of SA(K, r, [...]) is meant to be a set abstraction level with K local regions of ball radius r (unfortunately, K is overloaded later as the number of classes...). In the code, I am trying to figure out where this K parameter (the number of local regions) is located. I'm not sure if I see it, because the SAModule seems to instead use a self.ratio term:

pytorch_geometric/examples/pointnet2_classification.py

Lines 12 to 27 in 50b7bfc

	class SAModule(torch.nn.Module):
	def __init__(self, ratio, r, nn):
	super().__init__()
	self.ratio = ratio
	self.r = r
	self.conv = PointConv(nn, add_self_loops=False)
	def forward(self, x, pos, batch):
	idx = fps(pos, batch, ratio=self.ratio)
	row, col = radius(pos, pos[idx], self.r, batch, batch[idx],
	max_num_neighbors=64)
	edge_index = torch.stack([col, row], dim=0)
	x_dst = None if x is None else x[idx]
	x = self.conv((x, x_dst), (pos, pos[idx]), edge_index)
	pos, batch = pos[idx], batch[idx]
	return x, pos, batch

Is this an equivalently way of describing K local regions? I am unsure, especially because this "ratio" seems to be a sampling ratio in the farthest point algorithm:

https://pytorch-geometric.readthedocs.io/en/latest/modules/nn.html?highlight=fps#torch_geometric.nn.pool.fps

which seems a bit different from the number of local regions? Though I guess increasing the number of local regions could be like increasing the sampling ratio?

For the most part, the other parts of the code seem to match the paper:

• The 0.2 and 0.4 in the first two set abstraction levels are exactly as described in the paper.
• There are two SA layers, and then a third SA layer which is implemented using GlobalSAModule instead of SAModule
• The MLPs seem to match what's in the paper.

Hence why I'm curious about this missing parameter.

[rusty1s]

Instead of fixing the number of regions K, we use the ratio argument instead, which denotes the fraction of regions we want to use in relation to the number of input points. If you have 1024 points in your cloud, and set K=512, then this is equivalent to setting ratio=0.5.

[DanielTakeshi]

Thanks @rusty1s for your clarification!