Name: Tashvik Dhamija (tdhamija)
python train.py --task cls
python eval_cls.py
Test accuracy: 97.38%






Lamps and vases often have similar shapes. Since the model only learns from point positions, with no other information about the object, it can get confused between them.
The chair it fails on is folded, so its point cloud is concentrated like a lamp or vase, instead of spread out like a normal chair point cloud. That's why it gets it wrong.
python train.py --task seg
python eval_seg.py
Test accuracy: 89.90%
Segmentation color legend (applies to every segmentation visualization on this page):










The model does well on samples that look like a common chair. But for chair types with a different shape, or an extra element like a futon-style chair, it struggles, probably because it doesn't see enough samples of those shapes during training.
| Rotation | Classification accuracy | Segmentation accuracy |
|---|---|---|
| 0° | 97.38% | 89.90% |
| 15° | 94.12% | 86.74% |
| 30° | 84.89% | 80.55% |
| 45° | 70.83% | 73.15% |
| 90° | 63.80% | 58.28% |
| 180° | 31.58% | 48.27% |
Procedure: rotated the input point clouds around the up (Y) axis by each angle at evaluation time, using the Q1/Q2 checkpoints as is, and measured how accuracy changes.












Since the model only learns to use spatial info, rotation puts parts of the object in areas the model doesn't expect, which confuses it. The model never learns to deal with rotation at all.
Classification suffers more than segmentation, since it relies on one globally pooled feature for the whole object. Once that pooled feature is thrown off by rotation, there's nothing else to fall back on. Segmentation still has local per-point features to work with, so it holds up a bit better.
| Points | Classification accuracy | Segmentation accuracy |
|---|---|---|
| 5000 | 96.96% | 89.85% |
| 2000 | 96.43% | 89.32% |
| 1000 | 96.43% | 88.40% |
| 500 | 96.43% | 86.55% |
| 100 | 93.18% | 79.72% |
| 50 | 89.82% | 76.25% |
Procedure: randomly subsampled the input point clouds down to each point count at evaluation time, using the Q1/Q2 checkpoints as is, and measured how accuracy changes.












Classification doesn't suffer much from reducing points. Even with as few as 50 points, the model can still identify the global structure of the object from the pooled features.
Segmentation needs enough point density to tell apart where one part ends and another begins. With very few points, there isn't enough local detail left near those part boundaries, so segmentation accuracy drops more than classification. Classification only needs the rough global shape, which survives sparsity fine, segmentation needs fine per-point detail, which doesn't.
Implemented DGCNN (Dynamic Graph CNN). For each point, we find its k=20 nearest neighbors and build a local graph. Three EdgeConv layers (3 to 64 to 128 to 256 channels) learn from each point and its neighbor offsets, then max-pool over the neighbors. The classification variant adds a global max-pool and FC head, same as cls_model. The segmentation variant applies an FC head directly on the per-point features, same as seg_model.
Finding neighbors this way gets expensive fast as point count grows, so we first subsample the input down to 1024 points for classification and 2048 points for segmentation using farthest point sampling (pytorch3d's sample_farthest_points). This matches the point count used in the original DGCNN paper.
python train.py --task cls --model_type dgcnn --num_points 1024 --batch_size 8
python train.py --task seg --model_type dgcnn --num_points 2048 --batch_size 8
python eval_cls.py --model_type dgcnn --num_points 1024
python eval_seg.py --model_type dgcnn --num_points 2048
| Task | PointNet (Q1/Q2) | DGCNN (Q4) |
|---|---|---|
| Classification | 97.38% | 97.17% |
| Segmentation | 89.90% | 91.60% |





No chair failure case was found in this test run (DGCNN classified every chair in the batch correctly).






Classification: DGCNN gets almost the same accuracy (97.17% vs 97.38%) using far fewer points, 1024 instead of 10000. This shows it needs much less data to reach the same level of accuracy.
Segmentation: DGCNN does better (91.60% vs 89.90%) because it builds better local context through EdgeConv, which helps distinguish nearby points near part boundaries.
Limitation: DGCNN is more expensive. Building the neighbor graph and running EdgeConv adds extra computation, so it has higher complexity than plain PointNet.