├── pointnet ├── data │ └── .gitkeep ├── utils │ ├── __init__.py │ ├── misc.py │ ├── model_checkpoint.py │ └── metrics.py ├── dataloaders │ ├── __init__.py │ ├── modelnet.py │ └── shapenet_partseg.py ├── checkpoints │ ├── auto_encoding │ │ └── .gitkeep │ ├── segmentation │ │ └── .gitkeep │ └── classification │ │ └── .gitkeep ├── train_ae.py ├── model.py ├── train_cls.py ├── train_seg.py └── visualization.ipynb ├── Figure ├── ae.png ├── cls.png ├── feat.png ├── seg.png ├── pointnet_teaser.png └── Screenshot_example.png ├── .gitignore ├── LICENSE └── README.md /pointnet/data/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /pointnet/utils/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /pointnet/dataloaders/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /pointnet/checkpoints/auto_encoding/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /pointnet/checkpoints/segmentation/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /pointnet/checkpoints/classification/.gitkeep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Figure/ae.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/HEAD/Figure/ae.png -------------------------------------------------------------------------------- /Figure/cls.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/HEAD/Figure/cls.png -------------------------------------------------------------------------------- /Figure/feat.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/HEAD/Figure/feat.png -------------------------------------------------------------------------------- /Figure/seg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/HEAD/Figure/seg.png -------------------------------------------------------------------------------- /Figure/pointnet_teaser.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/HEAD/Figure/pointnet_teaser.png -------------------------------------------------------------------------------- /Figure/Screenshot_example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/HEAD/Figure/Screenshot_example.png -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | pointnet/data/** 2 | pointnet/checkpoints/classification/** 3 | pointnet/checkpoints/auto_encoding/** 4 | pointnet/checkpoints/segmentation/** 5 | !**/.gitkeep 6 | 7 | __pycache__/ 8 | *.py[cod] 9 | *$py.class 10 | 11 | # C extensions 12 | *.so 13 | 14 | # Distribution / packaging 15 | .Python 16 | build/ 17 | develop-eggs/ 18 | dist/ 19 | downloads/ 20 | eggs/ 21 | .eggs/ 22 | lib/ 23 | lib64/ 24 | parts/ 25 | sdist/ 26 | var/ 27 | wheels/ 28 | pip-wheel-metadata/ 29 | share/python-wheels/ 30 | *.egg-info/ 31 | .installed.cfg 32 | *.egg 33 | .ipynb_checkpoints 34 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | KAIST CS479: Machine Learning for 3D Data (2023 Fall) Programming Assignment 1 2 | 3 | MIT License 4 | 5 | Copyright (c) 2023 KAIST Geometric AI Group 6 | 7 | Permission is hereby granted, free of charge, to any person obtaining a copy 8 | of this software and associated documentation files (the "Software"), to deal 9 | in the Software without restriction, including without limitation the rights 10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | copies of the Software, and to permit persons to whom the Software is 12 | furnished to do so, subject to the following conditions: 13 | 14 | The above copyright notice and this permission notice shall be included in all 15 | copies or substantial portions of the Software. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 | SOFTWARE. 24 | -------------------------------------------------------------------------------- /pointnet/utils/misc.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import numpy as np 3 | import os.path as osp 4 | import matplotlib.pyplot as plt 5 | import json 6 | 7 | def pc_normalize(pc: np.ndarray): 8 | m = pc.mean(0) 9 | pc = pc - m 10 | s = np.max(np.sqrt(np.sum(pc**2, -1))) 11 | pc = pc / s 12 | 13 | return pc 14 | 15 | 16 | 17 | def save_samples(pointclouds: torch.Tensor, groundtruths: torch.Tensor, preds: torch.Tensor, filename: str): 18 | """ 19 | pointclouds: [num_sample, num_points, 3] 20 | groundtruths: [num_sample, num_points] 21 | preds: [num_sample, num_points] 22 | filename: output filename 23 | """ 24 | fin = open("data/shapenet_part_seg_hdf5_data/part_color_mapping.json") 25 | color_maps = np.array(json.load(fin)) 26 | color_mapping = lambda x : color_maps[x] 27 | fin.close() 28 | 29 | assert pointclouds.shape[:2] == groundtruths.shape == preds.shape 30 | 31 | num_sample = pointclouds.shape[0] 32 | pcs = pointclouds.clone().detach().cpu().numpy() 33 | gts = groundtruths.clone().detach().cpu().numpy() 34 | preds = preds.clone().detach().cpu().numpy() 35 | 36 | fig = plt.figure(figsize=(2*4, num_sample*4)) 37 | 38 | for i in range(num_sample): 39 | ax = fig.add_subplot(num_sample, 2, 2*i+1, projection="3d") 40 | ax.scatter(pcs[i,:,0], pcs[i,:,2], pcs[i,:,1], c=color_mapping(gts[i])) 41 | 42 | ax.set_xlim(-.7, .7) 43 | ax.set_ylim(-.7, .7) 44 | ax.set_zlim(-.7, .7) 45 | ax.axis("off") 46 | 47 | ax = fig.add_subplot(num_sample, 2, 2*i+2, projection="3d") 48 | ax.scatter(pcs[i,:,0], pcs[i,:,2], pcs[i,:,1], c=color_mapping(preds[i])) 49 | 50 | ax.set_xlim(-.7, .7) 51 | ax.set_ylim(-.7, .7) 52 | ax.set_zlim(-.7, .7) 53 | ax.axis("off") 54 | 55 | plt.tight_layout() 56 | fig.suptitle("Left: Groundtruths Right: Predictions", fontsize=18) 57 | plt.savefig(filename) 58 | 59 | -------------------------------------------------------------------------------- /pointnet/dataloaders/modelnet.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | import torch 3 | import numpy as np 4 | import h5py 5 | import os 6 | import os.path as osp 7 | from utils.misc import pc_normalize 8 | 9 | 10 | class ModelNetDataset(torch.utils.data.Dataset): 11 | def __init__(self, phase: str, data_dir: str): 12 | super().__init__() 13 | self.phase = phase 14 | self.data_dir = data_dir 15 | self.modelnet_dir = osp.join(data_dir, "modelnet40_ply_hdf5_2048") 16 | 17 | self.download_data() 18 | 19 | # ModelNet has only train and test splits. 20 | if phase == "val": 21 | phase = "test" 22 | 23 | with open(osp.join(self.modelnet_dir, f"{phase}_files.txt")) as f: 24 | file_list = [line.rstrip() for line in f] 25 | 26 | self.data = [] 27 | self.label = [] 28 | self.normal = [] 29 | for fn in file_list: 30 | f = h5py.File(osp.join(self.modelnet_dir, osp.basename(fn))) 31 | self.data.append(f["data"][:]) 32 | self.label.append(f["label"][:]) 33 | self.normal.append(f["normal"][:]) 34 | 35 | self.data = np.concatenate(self.data, 0).astype(np.float32) 36 | self.label = np.concatenate(self.label, 0).astype(np.int_) 37 | self.normal = np.concatenate(self.normal, 0).astype(np.float32) 38 | 39 | def __getitem__(self, idx): 40 | pc = torch.from_numpy(pc_normalize(self.data[idx])) 41 | label = torch.from_numpy(self.label[idx]).squeeze() 42 | 43 | return pc, label 44 | 45 | def __len__(self): 46 | return len(self.data) 47 | 48 | def download_data(self): 49 | if not osp.exists(self.data_dir): 50 | os.makedirs(self.data_dir, exist_ok=True) 51 | if not osp.exists(self.modelnet_dir): 52 | www = "https://shapenet.cs.stanford.edu/media/modelnet40_ply_hdf5_2048.zip" 53 | zipfile = osp.basename(www) 54 | os.system(f"wget --no-check-certificate {www}; unzip {zipfile}") 55 | os.system(f"mv {zipfile[:-4]} {self.data_dir}") 56 | os.system(f"rm {zipfile}") 57 | 58 | 59 | def get_data_loaders( 60 | data_dir, batch_size, phases: List[str] = ["train", "val", "test"] 61 | ): 62 | datasets = [] 63 | dataloaders = [] 64 | for ph in phases: 65 | ds = ModelNetDataset(ph, data_dir) 66 | dl = torch.utils.data.DataLoader( 67 | ds, batch_size, shuffle=ph == "train", drop_last=ph == "train" 68 | ) 69 | 70 | datasets.append(ds) 71 | dataloaders.append(dl) 72 | 73 | return datasets, dataloaders 74 | -------------------------------------------------------------------------------- /pointnet/dataloaders/shapenet_partseg.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | import torch 3 | import numpy as np 4 | import h5py 5 | import os 6 | import os.path as osp 7 | from utils.misc import pc_normalize 8 | 9 | 10 | class ShapeNetPartSegDataset(torch.utils.data.Dataset): 11 | def __init__(self, phase: str, data_dir: str): 12 | super().__init__() 13 | self.phase = phase 14 | self.data_dir = data_dir 15 | self.shapenet_dir = osp.join(data_dir, "shapenet_part_seg_hdf5_data") 16 | 17 | self.download_data() 18 | 19 | with open(osp.join(self.shapenet_dir, f"{phase}_hdf5_file_list.txt")) as f: 20 | file_list = [line.rstrip() for line in f] 21 | 22 | self.data = [] 23 | self.pc_label = [] 24 | self.class_label = [] 25 | for fn in file_list: 26 | f = h5py.File(osp.join(self.shapenet_dir, fn)) 27 | self.data.append(f["data"][:]) 28 | self.pc_label.append(f["pid"][:]) 29 | self.class_label.append(f["label"][:]) 30 | 31 | self.data = np.concatenate(self.data, 0).astype(np.float32) 32 | self.pc_label = np.concatenate(self.pc_label, 0).astype(np.int_) 33 | self.class_label = np.concatenate(self.class_label, 0).astype(np.int_) 34 | 35 | def __getitem__(self, idx): 36 | pc = torch.from_numpy(pc_normalize(self.data[idx])) 37 | pc_label = torch.from_numpy(self.pc_label[idx]) 38 | class_label = torch.from_numpy(self.class_label[idx]).squeeze() 39 | return pc, pc_label, class_label 40 | 41 | def __len__(self): 42 | return len(self.data) 43 | 44 | def download_data(self): 45 | if not osp.exists(self.data_dir): 46 | os.makedirs(self.data_dir, exist_ok=True) 47 | if not osp.exists(self.shapenet_dir): 48 | www = "https://shapenet.cs.stanford.edu/media/shapenet_part_seg_hdf5_data.zip" 49 | zipfile = osp.basename(www) 50 | os.system(f"wget --no-check-certificate {www}; unzip {zipfile}") 51 | os.system(f"mv hdf5_data {self.shapenet_dir}") 52 | os.system(f"rm {zipfile}") 53 | 54 | def get_data_loaders( 55 | data_dir, batch_size, phases: List[str] = ["train", "val", "test"] 56 | ): 57 | datasets = [] 58 | dataloaders = [] 59 | for ph in phases: 60 | ds = ShapeNetPartSegDataset(ph, data_dir) 61 | dl = torch.utils.data.DataLoader( 62 | ds, batch_size, shuffle=ph == "train", drop_last=ph == "train" 63 | ) 64 | 65 | datasets.append(ds) 66 | dataloaders.append(dl) 67 | 68 | return datasets, dataloaders 69 | -------------------------------------------------------------------------------- /pointnet/utils/model_checkpoint.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import os 3 | import os.path as osp 4 | 5 | 6 | class CheckpointManager: 7 | def __init__( 8 | self, 9 | dirpath: str, 10 | metric_name: str, 11 | mode: str = "min", 12 | topk: int = 1, 13 | verbose: bool = False, 14 | ): 15 | """ 16 | dirpath: directory to save the model file. 17 | metric_name: the name of metric to track. 18 | mode: one of {min, max}. The decision to save current ckpt is based on 19 | either minimizing the quantity or maximizing the quantity. 20 | e.g., acc: max, loss: min 21 | topk: # of checkpoints to save. 22 | verbose: verbosity mode 23 | """ 24 | self.dirpath = dirpath 25 | self.metric_name = metric_name 26 | self.mode = mode 27 | self.topk = topk 28 | self.verbose = verbose 29 | 30 | self._cache = [] 31 | 32 | os.makedirs(self.dirpath, exist_ok=True) 33 | 34 | def update(self, model: torch.nn.Module, epoch: int, metric: float, fname: str): 35 | assert isinstance(epoch, int) and isinstance(metric, float) 36 | 37 | # filename = osp.join(self.dirpath, f"epoch={epoch}-{self.metric_name}={metric}.ckpt") 38 | filename = osp.join(self.dirpath, f"{fname}_epoch{epoch}_metric{metric}.ckpt") 39 | 40 | save_check = False 41 | if len(self._cache) < self.topk: 42 | save_check = True 43 | else: 44 | assert len(self._cache) <= self.topk 45 | 46 | for fn, met in self._cache: 47 | if self.mode == "min": 48 | if metric < met: 49 | save_check = True 50 | break 51 | elif self.mode == "max": 52 | if metric > met: 53 | save_check = True 54 | break 55 | 56 | if save_check: 57 | self._cache.append((filename, metric)) 58 | assert not osp.exists(filename) 59 | torch.save(model.state_dict(), filename) 60 | if self.verbose: 61 | print(f"saving checkpoint to {filename}") 62 | 63 | # sort cache 64 | sorted_cache = sorted( 65 | self._cache, key=lambda x: x[1], reverse=self.mode == "max" 66 | ) 67 | self._cache = sorted_cache[: self.topk] 68 | # delete an outdated checkpoint file. 69 | for fn, met in sorted_cache[self.topk :]: 70 | assert osp.exists(fn) 71 | os.system(f"rm {fn}") 72 | 73 | def load_best_ckpt(self, model, device): 74 | try: 75 | ckptname = self._cache[0][0] 76 | ckpt = torch.load(ckptname, map_location=device) 77 | model.load_state_dict(ckpt) 78 | print(f"loaded best ckpt from {ckptname}") 79 | except: 80 | print("cannot load checkpoint") 81 | 82 | 83 | -------------------------------------------------------------------------------- /pointnet/train_ae.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn.functional as F 3 | import argparse 4 | from datetime import datetime 5 | from tqdm import tqdm 6 | from model import PointNetAutoEncoder 7 | from dataloaders.modelnet import get_data_loaders 8 | from utils.metrics import Accuracy 9 | from utils.model_checkpoint import CheckpointManager 10 | from pytorch3d.loss.chamfer import chamfer_distance 11 | 12 | 13 | 14 | def step(points, model): 15 | """ 16 | Input : 17 | - points [B, N, 3] 18 | Output : loss 19 | - loss [] 20 | - preds [B, N, 3] 21 | """ 22 | 23 | # TODO : Implement step function for AutoEncoder. 24 | # Hint : Use chamferDist defined in above 25 | # Hint : You can compute chamfer distance between two point cloud pc1 and pc2 by chamfer_distance(pc1, pc2) 26 | 27 | preds = None 28 | loss = None 29 | 30 | return loss, preds 31 | 32 | 33 | def train_step(points, model, optimizer): 34 | loss, preds = step(points, model) 35 | 36 | # TODO : Implement backpropagation using optimizer and loss 37 | 38 | return loss, preds 39 | 40 | 41 | def validation_step(points, model): 42 | loss, preds = step(points, model) 43 | 44 | return loss, preds 45 | 46 | 47 | def main(args): 48 | global device 49 | device = "cpu" if args.gpu == -1 else f"cuda:{args.gpu}" 50 | 51 | model = PointNetAutoEncoder(num_points=2048) 52 | model = model.to(device) 53 | 54 | optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) 55 | scheduler = torch.optim.lr_scheduler.MultiStepLR( 56 | optimizer, milestones=[30, 80], gamma=0.5 57 | ) 58 | 59 | # automatically save only topk checkpoints. 60 | if args.save: 61 | checkpoint_manager = CheckpointManager( 62 | dirpath=datetime.now().strftime("checkpoints/auto_encoding/%m-%d_%H-%M-%S"), 63 | metric_name="val_loss", 64 | mode="min", 65 | topk=2, 66 | verbose=True, 67 | ) 68 | 69 | (train_ds, val_ds, test_ds), (train_dl, val_dl, test_dl) = get_data_loaders( 70 | data_dir="./data", batch_size=args.batch_size, phases=["train", "val", "test"] 71 | ) 72 | 73 | for epoch in range(args.epochs): 74 | 75 | # training step 76 | model.train() 77 | pbar = tqdm(train_dl) 78 | train_epoch_loss = [] 79 | for points, _ in pbar: 80 | train_batch_loss, train_batch_preds = train_step(points, model, optimizer) 81 | train_epoch_loss.append(train_batch_loss) 82 | pbar.set_description( 83 | f"{epoch+1}/{args.epochs} epoch | loss: {train_batch_loss:.4f}" 84 | ) 85 | 86 | train_epoch_loss = sum(train_epoch_loss) / len(train_epoch_loss) 87 | 88 | # validataion step 89 | model.eval() 90 | with torch.no_grad(): 91 | val_epoch_loss = [] 92 | for points, _ in val_dl: 93 | val_batch_loss, val_batch_preds = validation_step(points, model) 94 | val_epoch_loss.append(val_batch_loss) 95 | 96 | val_epoch_loss = sum(val_epoch_loss) / len(val_epoch_loss) 97 | print( 98 | f"train loss: {train_epoch_loss:.4f} | val loss: {val_epoch_loss:.4f}" 99 | ) 100 | 101 | if args.save: 102 | checkpoint_manager.update(model, epoch, round(val_epoch_loss.item(), 4), f"AutoEncoding_ckpt") 103 | 104 | scheduler.step() 105 | 106 | if args.save: 107 | checkpoint_manager.load_best_ckpt(model, device) 108 | model.eval() 109 | with torch.no_grad(): 110 | test_epoch_loss = [] 111 | for points, _ in test_dl: 112 | test_batch_loss, test_batch_preds = validation_step(points, model) 113 | test_epoch_loss.append(test_batch_loss) 114 | 115 | test_epoch_loss = sum(test_epoch_loss) / len(test_epoch_loss) 116 | print(f"test loss: {test_epoch_loss:.4f}") 117 | 118 | 119 | if __name__ == "__main__": 120 | parser = argparse.ArgumentParser(description="PointNet ModelNet40 AutoEncoder") 121 | parser.add_argument("--epochs", type=int, default=100) 122 | parser.add_argument("--batch_size", type=int, default=128) 123 | parser.add_argument("--lr", type=float, default=1e-3) 124 | 125 | args = parser.parse_args() 126 | args.gpu = 0 127 | args.save = True 128 | 129 | main(args) 130 | -------------------------------------------------------------------------------- /pointnet/utils/metrics.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import torch 3 | import torch.nn as nn 4 | 5 | 6 | class Accuracy(nn.Module): 7 | def __init__(self): 8 | super().__init__() 9 | self.correct = 0 10 | self.total = 0 11 | self.history = [] 12 | 13 | def forward(self, preds: torch.Tensor, targets: torch.Tensor): 14 | """ 15 | process one batch and accumulate the result. 16 | """ 17 | assert preds.shape == targets.shape 18 | with torch.no_grad(): 19 | c = torch.sum(preds == targets) 20 | t = targets.numel() 21 | 22 | self.correct += c 23 | self.total += t 24 | 25 | return c.float() / t 26 | 27 | def compute_epoch(self): 28 | """ 29 | take a mean of accumulated results so far and log it into self.history 30 | """ 31 | acc = self.correct.float() / self.total 32 | self.history.append(acc) 33 | self.reset() 34 | return acc 35 | 36 | def reset(self): 37 | self.correct = 0 38 | self.total = 0 39 | 40 | 41 | class mIoU(nn.Module): 42 | def __init__(self): 43 | super().__init__() 44 | self.iou_sum = 0 45 | self.total = 0 46 | self.history = [] 47 | 48 | """ 49 | ShapeNet Part Anno Dataset Overview 50 | 51 | | | 52 | 0 Airplane | 02691156 | [0, 1, 2, 3] 53 | 1 Bag | 02773838 | [4, 5] 54 | 2 Cap | 02954340 | [6, 7] 55 | 3 Car | 02958343 | [8, 9, 10, 11] 56 | 4 Chair | 03001627 | [12, 13, 14 15] 57 | 5 Earphone | 03261776 | [16, 17, 18] 58 | 6 Guitar | 03467517 | [19, 20, 21] 59 | 7 Knife | 03624134 | [22, 23] 60 | 8 Lamp | 03636649 | [24, 25, 26, 27] 61 | 9 Laptop | 03642806 | [28, 29] 62 | 10 Motorbike | 03790512 | [30, 31, 32, 33, 34, 35] 63 | 11 Mug | 03797390 | [36, 37] 64 | 12 Pistol | 03948459 | [38, 39, 40] 65 | 13 Rocket | 04099429 | [41, 42, 43] 66 | 14 Skateboard | 04225987 | [44, 45, 46] 67 | 15 Table | 04379243 | [47, 48, 49] 68 | 69 | """ 70 | self.idx2pids = { 71 | 0: [0, 1, 2, 3], 72 | 1: [4, 5], 73 | 2: [6, 7], 74 | 3: [8, 9, 10, 11], 75 | 4: [12, 13, 14, 15], 76 | 5: [16, 17, 18], 77 | 6: [19, 20, 21], 78 | 7: [22, 23], 79 | 8: [24, 25, 26, 27], 80 | 9: [28, 29], 81 | 10: [30, 31, 32, 33, 34, 35], 82 | 11: [35, 37], 83 | 12: [38, 39, 40], 84 | 13: [41, 42, 43], 85 | 14: [44, 45, 46], 86 | 15: [47, 48, 49], 87 | } 88 | 89 | def forward( 90 | self, logits: torch.Tensor, targets: torch.Tensor, class_labels: torch.Tensor 91 | ): 92 | """ 93 | Input: 94 | logits: [B, 50, num_points] 95 | targets: [B,num_points] 96 | class_labels: [B] 97 | Output: 98 | iou_per_batch 99 | batch_masked_pred: [B, num_points] A masked prediction where it ignores other categories' point labels when picking the highest logit. 100 | """ 101 | with torch.no_grad(): 102 | B, N = logits.shape[0], logits.shape[-1] 103 | device = logits.device 104 | batch_iou = torch.zeros(B, dtype=torch.float).to(device) 105 | batch_masked_pred = torch.zeros(B, N, dtype=torch.long).to(device) 106 | for i in range(B): 107 | cl = int(class_labels[i]) 108 | pids = self.idx2pids[cl] 109 | 110 | logit = logits[i] 111 | target = targets[i] 112 | mask = torch.zeros_like(logit) 113 | mask[pids, :] = 1 114 | logit.masked_fill(mask == 0, -1e-9) 115 | masked_pred = torch.argmax(logit, dim=0) 116 | batch_masked_pred[i] = masked_pred 117 | 118 | for pid in pids: 119 | pd = masked_pred == pid 120 | gt = target == pid 121 | 122 | union = (gt | pd).sum() 123 | inter = (gt & pd).sum() 124 | 125 | if union == 0: 126 | batch_iou[i] += 1 127 | else: 128 | batch_iou[i] += inter / union 129 | 130 | batch_iou[i] /= len(pids) 131 | 132 | self.iou_sum += batch_iou.sum() 133 | self.total += class_labels.numel() 134 | 135 | iou_per_batch = batch_iou.sum() / class_labels.numel() 136 | return iou_per_batch, batch_masked_pred 137 | 138 | def compute_epoch(self): 139 | iou = self.iou_sum / self.total 140 | self.history.append(iou) 141 | self.reset() 142 | return iou 143 | 144 | def reset(self): 145 | self.iou_sum = 0 146 | self.total = 0 147 | -------------------------------------------------------------------------------- /pointnet/model.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | from torch.autograd import Variable 5 | 6 | 7 | class STNKd(nn.Module): 8 | # T-Net a.k.a. Spatial Transformer Network 9 | def __init__(self, k: int): 10 | super().__init__() 11 | self.k = k 12 | self.conv1 = nn.Sequential(nn.Conv1d(k, 64, 1), nn.BatchNorm1d(64)) 13 | self.conv2 = nn.Sequential(nn.Conv1d(64, 128, 1), nn.BatchNorm1d(128)) 14 | self.conv3 = nn.Sequential(nn.Conv1d(128, 1024, 1), nn.BatchNorm1d(1024)) 15 | 16 | self.fc = nn.Sequential( 17 | nn.Linear(1024, 512), 18 | nn.BatchNorm1d(512), 19 | nn.ReLU(), 20 | nn.Linear(512, 256), 21 | nn.BatchNorm1d(256), 22 | nn.ReLU(), 23 | nn.Linear(256, k * k), 24 | ) 25 | 26 | def forward(self, x): 27 | """ 28 | Input: [B,k,N] 29 | Output: [B,k,k] 30 | """ 31 | B = x.shape[0] 32 | device = x.device 33 | x = F.relu(self.conv1(x)) 34 | x = F.relu(self.conv2(x)) 35 | x = F.relu(self.conv3(x)) 36 | x = torch.max(x, 2)[0] 37 | 38 | x = self.fc(x) 39 | 40 | # Followed the original implementation to initialize a matrix as I. 41 | identity = ( 42 | Variable(torch.eye(self.k, dtype=torch.float)) 43 | .reshape(1, self.k * self.k) 44 | .expand(B, -1) 45 | .to(device) 46 | ) 47 | x = x + identity 48 | x = x.reshape(-1, self.k, self.k) 49 | return x 50 | 51 | 52 | class PointNetFeat(nn.Module): 53 | """ 54 | Corresponds to the part that extracts max-pooled features. 55 | """ 56 | def __init__( 57 | self, 58 | input_transform: bool = False, 59 | feature_transform: bool = False, 60 | ): 61 | super().__init__() 62 | self.input_transform = input_transform 63 | self.feature_transform = feature_transform 64 | 65 | if self.input_transform: 66 | self.stn3 = STNKd(k=3) 67 | if self.feature_transform: 68 | self.stn64 = STNKd(k=64) 69 | 70 | # point-wise mlp 71 | # TODO : Implement point-wise mlp model based on PointNet Architecture. 72 | 73 | def forward(self, pointcloud): 74 | """ 75 | Input: 76 | - pointcloud: [B,N,3] 77 | Output: 78 | - Global feature: [B,1024] 79 | - ... 80 | """ 81 | 82 | # TODO : Implement forward function. 83 | pass 84 | 85 | 86 | class PointNetCls(nn.Module): 87 | def __init__(self, num_classes, input_transform, feature_transform): 88 | super().__init__() 89 | self.num_classes = num_classes 90 | 91 | # extracts max-pooled features 92 | self.pointnet_feat = PointNetFeat(input_transform, feature_transform) 93 | 94 | # returns the final logits from the max-pooled features. 95 | # TODO : Implement MLP that takes global feature as an input and return logits. 96 | 97 | def forward(self, pointcloud): 98 | """ 99 | Input: 100 | - pointcloud [B,N,3] 101 | Output: 102 | - logits [B,num_classes] 103 | - ... 104 | """ 105 | # TODO : Implement forward function. 106 | pass 107 | 108 | 109 | class PointNetPartSeg(nn.Module): 110 | def __init__(self, m=50): 111 | super().__init__() 112 | 113 | # returns the logits for m part labels each point (m = # of parts = 50). 114 | # TODO: Implement part segmentation model based on PointNet Architecture. 115 | pass 116 | 117 | def forward(self, pointcloud): 118 | """ 119 | Input: 120 | - pointcloud: [B,N,3] 121 | Output: 122 | - logits: [B,50,N] | 50: # of point labels 123 | - ... 124 | """ 125 | # TODO: Implement forward function. 126 | pass 127 | 128 | 129 | class PointNetAutoEncoder(nn.Module): 130 | def __init__(self, num_points): 131 | super().__init__() 132 | self.pointnet_feat = PointNetFeat() 133 | 134 | # Decoder is just a simple MLP that outputs N x 3 (x,y,z) coordinates. 135 | # TODO : Implement decoder. 136 | 137 | def forward(self, pointcloud): 138 | """ 139 | Input: 140 | - pointcloud [B,N,3] 141 | Output: 142 | - pointcloud [B,N,3] 143 | - ... 144 | """ 145 | # TODO : Implement forward function. 146 | pass 147 | 148 | 149 | def get_orthogonal_loss(feat_trans, reg_weight=1e-3): 150 | """ 151 | a regularization loss that enforces a transformation matrix to be a rotation matrix. 152 | Property of rotation matrix A: A*A^T = I 153 | """ 154 | if feat_trans is None: 155 | return 0 156 | 157 | B, K = feat_trans.shape[:2] 158 | device = feat_trans.device 159 | 160 | identity = torch.eye(K).to(device)[None].expand(B, -1, -1) 161 | mat_square = torch.bmm(feat_trans, feat_trans.transpose(1, 2)) 162 | 163 | mat_diff = (identity - mat_square).reshape(B, -1) 164 | 165 | return reg_weight * mat_diff.norm(dim=1).mean() 166 | -------------------------------------------------------------------------------- /pointnet/train_cls.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn.functional as F 3 | import argparse 4 | from datetime import datetime 5 | from tqdm import tqdm 6 | from model import PointNetCls, get_orthogonal_loss 7 | from dataloaders.modelnet import get_data_loaders 8 | from utils.metrics import Accuracy 9 | from utils.model_checkpoint import CheckpointManager 10 | 11 | 12 | def step(points, labels, model): 13 | """ 14 | Input : 15 | - points [B, N, 3] 16 | - ground truth labels [B] 17 | Output : loss 18 | - loss [] 19 | - preds [B] 20 | """ 21 | 22 | # TODO : Implement step function for classification. 23 | 24 | loss = None 25 | preds = None 26 | return loss, preds 27 | 28 | 29 | def train_step(points, labels, model, optimizer, train_acc_metric): 30 | loss, preds = step(points, labels, model) 31 | train_batch_acc = train_acc_metric(preds, labels.to(device)) 32 | 33 | # TODO : Implement backpropagation using optimizer and loss 34 | 35 | return loss, train_batch_acc 36 | 37 | 38 | def validation_step(points, labels, model, val_acc_metric): 39 | loss, preds = step(points, labels, model) 40 | val_batch_acc = val_acc_metric(preds, labels) 41 | 42 | return loss, val_batch_acc 43 | 44 | 45 | def main(args): 46 | global device 47 | device = "cpu" if args.gpu == -1 else f"cuda:{args.gpu}" 48 | 49 | model = PointNetCls(num_classes=40, input_transform=True, feature_transform=True) 50 | model = model.to(device) 51 | 52 | optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) 53 | scheduler = torch.optim.lr_scheduler.MultiStepLR( 54 | optimizer, milestones=[30, 80], gamma=0.5 55 | ) 56 | 57 | # automatically save only topk checkpoints. 58 | if args.save: 59 | checkpoint_manager = CheckpointManager( 60 | # Specify the directory to save checkpoints. 61 | dirpath=datetime.now().strftime( 62 | "checkpoints/classification/%m-%d_%H-%M-%S" 63 | ), 64 | metric_name="val_acc", 65 | mode="max", 66 | # the number of checkpoints to save. 67 | topk=2, 68 | # Whether to maximize or minimize metric. 69 | verbose=True, 70 | ) 71 | 72 | # It will download ModelNet dataset at the first time. 73 | (train_ds, val_ds, test_ds), (train_dl, val_dl, test_dl) = get_data_loaders( 74 | data_dir="./data", batch_size=args.batch_size, phases=["train", "val", "test"] 75 | ) 76 | 77 | train_acc_metric = Accuracy() 78 | val_acc_metric = Accuracy() 79 | test_acc_metric = Accuracy() 80 | 81 | for epoch in range(args.epochs): 82 | 83 | # training step 84 | model.train() 85 | pbar = tqdm(train_dl) 86 | train_epoch_loss = [] 87 | for points, labels in pbar: 88 | train_batch_loss, train_batch_acc = train_step( 89 | points, labels, model, optimizer, train_acc_metric 90 | ) 91 | train_epoch_loss.append(train_batch_loss) 92 | pbar.set_description( 93 | f"{epoch+1}/{args.epochs} epoch | loss: {train_batch_loss:.4f} | accuracy: {train_batch_acc*100:.1f}%" 94 | ) 95 | 96 | train_epoch_loss = sum(train_epoch_loss) / len(train_epoch_loss) 97 | train_epoch_acc = train_acc_metric.compute_epoch() 98 | 99 | # validataion step 100 | model.eval() 101 | with torch.no_grad(): 102 | val_epoch_loss = [] 103 | for points, labels in val_dl: 104 | points, labels = points.to(device), labels.to(device) 105 | val_batch_loss, val_batch_acc = validation_step( 106 | points, labels, model, val_acc_metric 107 | ) 108 | val_epoch_loss.append(val_batch_loss) 109 | 110 | val_epoch_loss = sum(val_epoch_loss) / len(val_epoch_loss) 111 | val_epoch_acc = val_acc_metric.compute_epoch() 112 | print( 113 | f"train loss: {train_epoch_loss:.4f} train acc: {train_epoch_acc*100:.1f}% | val loss: {val_epoch_loss:.4f} val acc: {val_epoch_acc*100:.1f}%" 114 | ) 115 | 116 | if args.save: 117 | """ 118 | Compare the current metric with history, and 119 | save ckpt only if the current metric is in topk. 120 | """ 121 | checkpoint_manager.update( 122 | model, epoch, round(val_epoch_acc.item() * 100, 2), f"Classification_ckpt" 123 | ) 124 | 125 | scheduler.step() 126 | 127 | if args.save: 128 | checkpoint_manager.load_best_ckpt(model, device) 129 | model.eval() 130 | with torch.no_grad(): 131 | for points, labels in test_dl: 132 | points, labels = points.to(device), labels.to(device) 133 | test_batch_loss, test_batch_acc = validation_step( 134 | points, labels, model, test_acc_metric 135 | ) 136 | test_acc = test_acc_metric.compute_epoch() 137 | 138 | print(f"test acc: {test_acc*100:.1f}%") 139 | 140 | 141 | if __name__ == "__main__": 142 | parser = argparse.ArgumentParser(description="PointNet ModelNet40 Classification") 143 | parser.add_argument("--epochs", type=int, default=100) 144 | parser.add_argument("--batch_size", type=int, default=128) 145 | parser.add_argument("--lr", type=float, default=1e-3) 146 | 147 | args = parser.parse_args() 148 | args.gpu = 0 149 | args.save = True 150 | 151 | main(args) 152 | -------------------------------------------------------------------------------- /pointnet/train_seg.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn.functional as F 3 | import argparse 4 | from datetime import datetime 5 | from tqdm import tqdm 6 | from model import PointNetPartSeg, get_orthogonal_loss 7 | from dataloaders.shapenet_partseg import get_data_loaders 8 | from utils.metrics import Accuracy, mIoU 9 | from utils.model_checkpoint import CheckpointManager 10 | from torch.autograd import Variable 11 | from utils.misc import save_samples 12 | import os.path as osp 13 | 14 | 15 | def step(points, pc_labels, class_labels, model): 16 | """ 17 | Input : 18 | - points [B, N, 3] 19 | - ground truth pc_labels [B, N] 20 | - ground truth class_labels [B] 21 | Output : loss 22 | - loss [] 23 | - logits [B, C, N] (C: num_class) 24 | - preds [B, N] 25 | """ 26 | 27 | # TODO : Implement step function for segmentation. 28 | 29 | loss = None 30 | logits = None 31 | preds = None 32 | return loss, logits, preds 33 | 34 | 35 | def train_step(points, pc_labels, class_labels, model, optimizer, train_acc_metric): 36 | loss, logits, preds = step( 37 | points, pc_labels, class_labels, model 38 | ) 39 | train_batch_acc = train_acc_metric(preds, pc_labels.to(device)) 40 | 41 | # TODO : Implement backpropagation using optimizer and loss 42 | 43 | return loss, train_batch_acc 44 | 45 | 46 | def validation_step( 47 | points, pc_labels, class_labels, model, val_acc_metric, val_iou_metric 48 | ): 49 | loss, logits, preds = step( 50 | points, pc_labels, class_labels, model 51 | ) 52 | val_batch_acc = val_acc_metric(preds, pc_labels) 53 | val_batch_iou, masked_preds = val_iou_metric(logits, pc_labels, class_labels) 54 | 55 | return loss, masked_preds, val_batch_acc, val_batch_iou 56 | 57 | 58 | def main(args): 59 | global device 60 | device = "cpu" if args.gpu == -1 else f"cuda:{args.gpu}" 61 | 62 | model = PointNetPartSeg() 63 | model = model.to(device) 64 | 65 | optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) 66 | scheduler = torch.optim.lr_scheduler.MultiStepLR( 67 | optimizer, milestones=[30, 80], gamma=0.5 68 | ) 69 | if args.save: 70 | checkpoint_manager = CheckpointManager( 71 | dirpath=datetime.now().strftime("checkpoints/segmentation/%m-%d_%H-%M-%S"), 72 | metric_name="val_iou", 73 | mode="max", 74 | topk=2, 75 | verbose=True, 76 | ) 77 | 78 | # It will download Shapenet Dataset at the first time. 79 | (train_ds, val_ds, test_ds), (train_dl, val_dl, test_dl) = get_data_loaders( 80 | data_dir="./data", batch_size=args.batch_size, phases=["train", "val", "test"] 81 | ) 82 | 83 | train_acc_metric = Accuracy() 84 | val_acc_metric = Accuracy() 85 | val_iou_metric = mIoU() 86 | 87 | for epoch in range(args.epochs): 88 | # training step 89 | model.train() 90 | pbar = tqdm(train_dl) 91 | train_epoch_loss = [] 92 | for points, pc_labels, class_labels in pbar: 93 | train_batch_loss, train_batch_acc = train_step( 94 | points, pc_labels, class_labels, model, optimizer, train_acc_metric 95 | ) 96 | train_epoch_loss.append(train_batch_loss) 97 | pbar.set_description( 98 | f"{epoch+1}/{args.epochs} epoch | loss: {train_batch_loss:.4f} | accuracy: {train_batch_acc*100:.1f}%" 99 | ) 100 | 101 | train_epoch_loss = sum(train_epoch_loss) / len(train_epoch_loss) 102 | train_epoch_acc = train_acc_metric.compute_epoch() 103 | 104 | # validataion step 105 | model.eval() 106 | with torch.no_grad(): 107 | val_epoch_loss = [] 108 | for points, pc_labels, class_labels in val_dl: 109 | points, pc_labels, class_labels = points.to(device), pc_labels.to(device), class_labels.to(device) 110 | val_batch_loss, val_batch_masked_preds, val_batch_acc, val_batch_iou = validation_step( 111 | points, 112 | pc_labels, 113 | class_labels, 114 | model, 115 | val_acc_metric, 116 | val_iou_metric, 117 | ) 118 | val_epoch_loss.append(val_batch_loss) 119 | 120 | val_epoch_loss = sum(val_epoch_loss) / len(val_epoch_loss) 121 | val_epoch_acc = val_acc_metric.compute_epoch() 122 | val_epoch_iou = val_iou_metric.compute_epoch() 123 | print( 124 | f"train loss: {train_epoch_loss:.4f} | train acc: {train_epoch_acc*100:.1f}% | val loss: {val_epoch_loss:.4f} | val acc: {val_epoch_acc*100:.1f}% | val mIoU: {val_epoch_iou*100:.1f}%" 125 | ) 126 | 127 | if args.save: 128 | checkpoint_manager.update( 129 | model, epoch, round(val_epoch_iou.item() * 100, 2), f"Segmentation_ckpt" 130 | ) 131 | scheduler.step() 132 | 133 | # After training, test on testset 134 | if args.save: 135 | checkpoint_manager.load_best_ckpt(model, device) 136 | model.eval() 137 | with torch.no_grad(): 138 | test_acc_metric = Accuracy() 139 | test_iou_metric = mIoU() 140 | for points, pc_labels, class_labels in test_dl: 141 | points, pc_labels, class_labels = points.to(device), pc_labels.to(device), class_labels.to(device) 142 | test_batch_loss, test_batch_masked_preds, test_batch_acc, test_batch_iou = validation_step( 143 | points, 144 | pc_labels, 145 | class_labels, 146 | model, 147 | test_acc_metric, 148 | test_iou_metric, 149 | ) 150 | test_acc = test_acc_metric.compute_epoch() 151 | test_iou = test_iou_metric.compute_epoch() 152 | 153 | print(f"test acc: {test_acc*100:.1f}% | test mIoU: {test_iou*100:.1f}%") 154 | save_samples(points[4:8], pc_labels[4:8], test_batch_masked_preds[4:8], "segmentation_samples.png") 155 | 156 | 157 | if __name__ == "__main__": 158 | parser = argparse.ArgumentParser(description="PointNet ShapeNet Part Segmentation") 159 | parser.add_argument("--epochs", type=int, default=100) 160 | parser.add_argument("--batch_size", type=int, default=128) 161 | parser.add_argument("--lr", type=float, default=1e-3) 162 | 163 | args = parser.parse_args() 164 | args.gpu = 0 165 | args.save = True 166 | 167 | main(args) 168 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |
2 |

3 | PointNet: Point Cloud Processing Network 4 |

5 |

6 | KAIST CS479: Machine Learning for 3D Data
7 | Programming Assignment 1 8 |

9 |
10 | 11 |
12 |

13 | Instructor: Minhyuk Sung (mhsung [at] kaist.ac.kr)
14 | TA: Jaihoon Kim (jh27kim [at] kaist.ac.kr)
15 | Credit: Hyunjin Kim (rlaguswls98 [at] kaist.ac.kr) 16 |

17 |
18 | 19 |
20 | 21 |
22 | 23 | ## Abstract 24 | 25 | [PointNet](https://arxiv.org/abs/1612.00593) is a fundamental yet powerful neural network processing point cloud data. In the first tutorial, we will learn how to use PointNet for different tasks including _classification_, _auto-encoding_, and _segmentation_ by implementing them. Since we aim to make you familiar with implementing neural network models and losses using Pytorch, we provide skeleton codes and what you have to do is just fill in the **TODO** parts of the codes. Before implementing codes, please read the [PointNet](https://arxiv.org/abs/1612.00593) paper together with [our brief summary](https://visual-ai-kaist.notion.site/Tutorial-1-PointNet-12e12629c85e40779f18633f1e7144b7) and the provided codes careful and check how codes flow. Also, we recommend you to read how to implement codes using Pytorch ([Pytorch Tutorial link](https://pytorch.org/tutorials/beginner/pytorch_with_examples.html)). 26 | 27 | 28 |
29 | Table of Content 30 | 31 | - [Abstract](#abstract) 32 | - [Setup](#setup) 33 | - [Code Structure](#code-structure) 34 | - [Tasks](#tasks) 35 | - [Task 0. Global Feature Extraction](#task-0-global-feature-extraction) 36 | - [Task 1. Point Cloud Classification](#task-1-point-cloud-classification) 37 | - [Task 2. Point Cloud Part Segmentation](#task-2-point-cloud-part-segmentation) 38 | - [Task 3. Point Cloud Auto-Encoding](#task-3-point-cloud-auto-encoding) 39 | - [Submission Guidelines](#submission-guidelines) 40 | - [Grading](#grading) 41 | - [Further Readings](#further-readings) 42 |
43 | 44 | ## Setup 45 | 46 | We recommend creating a virtual environment using `conda`. 47 | By following below commands, you can create and activate the conda environment. 48 | ``` 49 | conda create -n pointnet python=3.9 50 | conda activate pointnet 51 | ``` 52 | 53 | After that, install pytorch 1.13.0 and other essential packages by running: 54 | ``` 55 | conda install pytorch=1.13.0 torchvision pytorch-cuda=11.6 -c pytorch -c nvidia 56 | conda install -c fvcore -c iopath -c conda-forge fvcore iopath 57 | conda install pytorch3d -c pytorch3d 58 | ``` 59 | 60 | Lastly, install remained necessary packages using `pip`: 61 | ``` 62 | pip install tqdm h5py matplotlib 63 | ``` 64 | 65 | 66 | ## Code Structure 67 | Below shows the overall structure of this repository. Bascially, in this tutorial, what you have to do is implementing models and losses by filling in the **TODO** parts of below 4 files. 68 | ### TODOs 69 | ``` 70 | - model.py 71 | - train_cls.py 72 | - train_ae.py 73 | - train_seg.py 74 | ``` 75 | 76 | ``` 77 | pointnet 78 | │ 79 | ├── model.py <- PointNet models implementation. 80 | │ 81 | ├── dataloaders 82 | │ ├── modelnet.py <- Dataloader of ModelNet40 dataset. 83 | │ └── shapenet_partseg.py <- Dataloader of ShapeNet Part Annotation dataset. 84 | │ 85 | ├── utils 86 | │ ├── metrics.py <- Easy-to-use code to compute metrics. 87 | │ ├── misc.py <- Point cloud normalization ft. and code to save rendered point clouds. 88 | │ └── model_checkpoint.py <- Automatically save model checkpoints during training. 89 | │ 90 | ├── train_cls.py <- Run classification. 91 | ├── train_ae.py <- Run auto-encoding. 92 | ├── train_seg.py <- Run part segmentation. 93 | ├── visualization.ipynb <- Simple point cloud visualization example code. 94 | │ 95 | ├── data <- Project data. 96 | │ ├── modelnet40_ply_hdf5_2048 <- ModelNet40 97 | │ └── shapenet_part_seg_hdf5_data <- ShapeNet Part Annotation 98 | │ 99 | └── checkpoints <- Directory storing checkpoints. 100 | ├── classification 101 | │ └── mm-dd_HH-MM-SS/epoch=16-val_acc=88.6.ckpt 102 | ├── auto_encoding 103 | └── segmentation 104 | ``` 105 | 106 | ## Datasets 107 | The dataloader automatically downloads the ModelNet40 and ShapeNet datasets. If the link is not reachable, you can use the provided link for manual download [(link)](https://drive.google.com/drive/folders/1Ly2DbsBMBXp75CGCA4vnJ3uoyDxOJz84?usp=drive_link). After downloading, unzip the file and rename the directory to `modelnet40_ply_hdf5_2048` and `shapenet_part_seg_hdf5_data`, respectively (refer to [ModelNet dataloader](https://github.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/blob/b43db76f1e739093afbb117e4528362d87df4180/pointnet/dataloaders/shapenet_partseg.py#L15) and [ShapeNet dataloader](https://github.com/KAIST-Visual-AI-Group/CS479-Assignment-PointNet/blob/c270e998b13fa8f05ede0560d4dfb28f220ea2b0/pointnet/dataloaders/modelnet.py#L15)). Then, place them in the `./data` directory. 108 | 109 | 110 | ## Tasks 111 | 112 | ### Task 0. Global Feature Extraction 113 | 114 | ![image](Figure/feat.png) 115 | 116 | PointNet takes 3D point clouds(# points, 3) as inputs and extracts a 1024-sized global feature latent vector, which contains the geometric information of the input point clouds. This global feature vector will be used in the downstream tasks; point cloud classification, segmentation, and auto-encoding. In this part, you implement PointNetFeat model that only results out the global feature vector so that you can utilize this model for implementing the remaining 3 tasks. 117 | 118 | > :bulb: **The figure above is the guideline for the implementation, but you don't need to implement the code completely the same as it. You can assume that each MLP layer in the figure consists of MLP, batch normalization, and activation.** 119 | 120 | #### TODOs 121 | ``` 122 | - model.py 123 | ``` 124 | - Fill in the **TODO** in model.py > PointNetFeat class 125 | 126 | ※ When implementing PointNetFeat, you can utilize `STNKd` we give you in `model.py` code. 127 | 128 | ### Task 1. Point Cloud Classification 129 | ![image](Figure/cls.png) 130 | 131 | In point cloud classification tasks, PointNet inputs point clouds (# points, 3) and generates a 1024-sized global feature latent vector, which is then reduced to the number of categories (k) through multi-layer perceptrons, forming logits for each category. 132 | 133 | > :bulb: **The figure above is the guideline for the implementation, but you don't need to implement the code completely the same as it.** 134 | 135 | #### TODOs 136 | ``` 137 | - model.py 138 | - train_cls.py 139 | ``` 140 | - Fill in the **TODO** in `model.py` > `PointNetCls` 141 | - Fill in the **TODO** in `train_cls.py` > `step` and `train_step` 142 | 143 | You can start training the model by the following command. Also, at the end of the training it will automatically test the model on ModelNet40 dataset. 144 | 145 | ```bash 146 | python train_cls.py 147 | ``` 148 | 149 | Also, you can change `batch_size`, `lr`, and `epochs` by using the command below. 150 | ```bash 151 | python train_cls.py --batch_size {batch_size you want} --lr {lr you want} --epochs {epochs you want} 152 | ``` 153 | 154 | While training, if your model achieves the best result, model checkpoint will be saved automatically as `pointnet/classification/MM-DD_HH-MM-SS/Classification_ckpt_epoch{epoch}_metric:{val_Acc}.ckpt`. 155 | 156 | 157 | On ModelNet40 test set: 158 | | | Overall Acc | 159 | | ------------------------------ | ----------- | 160 | | Paper | 89.2 % | 161 | | Ours (w/o feature trans.) | 88.6 % | 162 | | Ours (w/ feature trans.) | 87.7 % | 163 | 164 | 165 | ### Task 2. Point Cloud Part Segmentation 166 | ![image](Figure/seg.png) 167 | 168 | For segmentation tasks, PointNet concatenates the second transformed feature with the global latent vector to form a point-wise feature tensor, which is then passed through an MLP to produce logits for m part labels. 169 | 170 | > :bulb: **The figure above is the guideline for the implementation, but you don't need to implement the code completely the same as it.** 171 | 172 | ### TODOs 173 | ``` 174 | - model.py 175 | - train_seg.py 176 | ``` 177 | - Fill in the **TODO** in `model.py` > `PointNetPartSeg` 178 | - Fill in the **TODO** in `train_seg.py` > `step` and `train_step` 179 | 180 | You can start training the model by the following command. Also, at the end of the training it will automatically test the model on ShapeNet part dataset. 181 | 182 | ```bash 183 | python train_seg.py 184 | ``` 185 | 186 | Also, you can change `batch_size`, `lr`, and `epochs` by using the command below. 187 | ```bash 188 | python train_seg.py --batch_size {batch_size you want} --lr {lr you want} --epochs {epochs you want} 189 | ``` 190 | 191 | While you are running `train_seg.py`, you are able to see progress bars: 192 | 193 | ![image](https://user-images.githubusercontent.com/37788686/158202971-159e4dc3-199a-4cf2-9b12-c01059a06a4c.png) 194 | 195 | 196 | We provide the code to measure instance mIoU in `utils/metrics.py`. 197 | 198 | While training, if your model achieves the best result, model checkpoint will be saved automatically as `pointnet/segmentation/MM-DD_HH-MM-SS/Segmentation_ckpt_epoch{epoch}_metric:{val_mIoU}.ckpt`. 199 | 200 | On ShapeNet Part test set: 201 | | | ins. mIoU | 202 | | ------ | --------- | 203 | | Paper | 83.7 % | 204 | | Ours | 83.6 % | 205 | 206 | 207 | ### Task 3. Point Cloud Auto-Encoding 208 | ![image](Figure/ae.png) 209 | 210 | The PointNet Auto-encoder comprises an encoder that inputs point clouds and produces a 1024-sized global feature latent vector, and an MLP decoder that expands this latent vector incrementally until it reaches N*3. This tensor is reshaped into (N, 3), representing N points in 3D coordinates. 211 | 212 | > :bulb: **The figure above is the guideline for the implementation, but you don't need to implement the code completely the same as it.** 213 | 214 | ### TODOs 215 | ``` 216 | - model.py 217 | - train_ae.py 218 | ``` 219 | - Fill in the **TODO** in `model.py` > `PointNetAutoEncoder` 220 | - Fill in the **TODO** in `train_ae.py` > `step` and `train_step` 221 | 222 | > :bulb: **We recommend not using the T-Net (input transform and feature transform) in the AE task. That's why we provide the PointNetFeat class without T-Net inside the PointNetAutoEncoder class definition.** 223 | 224 | You can start training the model by the following command. Also, at the end of the training it will automatically test the model on ModelNet40 dataset. 225 | 226 | ``` 227 | python train_ae.py 228 | ``` 229 | 230 | Also, you can change `batch_size`, `lr`, and `epochs` by using the command below. 231 | ```bash 232 | python train_ae.py --batch_size {batch_size you want} --lr {lr you want} --epochs {epochs you want} 233 | ``` 234 | 235 | While training, if your model achieves the best result, model checkpoint will be saved automatically as `pointnet/auto_encoding/MM-DD_HH-MM-SS/AutoEncoding_ckpt_epoch{epoch}_metric:{val_CD}.ckpt`. 236 | 237 | On ModelNet40 test set: 238 | | | Chamfer Dist. | 239 | | ------ | ------------- | 240 | | Ours | 0.0043 | 241 | 242 | 243 | ## What to Submit 244 | 245 | Compile the following files as a **ZIP** file named `{NAME}_{STUDENT_ID}.zip` and submit the file via KLMS. 246 | 1. 4 codes that you implemented: `model.py, train_ae.py, train_cls.py, train_seg.py`; 247 | 2. Model checkpoint file that achieves the best performance for classification, segmentation, and auto-encoding each; 248 | 3. A PDF file: {NAME}_{ID}.pdf that contains screenshot at the end of training for EACH TASK (classification, segmentation, and auto-encoding). 249 | 250 | Screenshot Example: 251 | 252 | ![image](Figure/Screenshot_example.png) 253 | 254 | ## Grading 255 | 256 | **You will receive a zero score if:** 257 | - **you do not submit,** 258 | - **your code is not executable in the Python environment we provided, or** 259 | - **you modify any code outside of the section marked with `TODO`.** 260 | 261 | **Plagiarism in any form will also result in a zero score and will be reported to the university.** 262 | 263 | **Your score will incur a 10% deduction for each missing item in the [Submission Guidelines](#submission-guidelines) section.** 264 | 265 | Otherwise, you will receive up to 30 points from this assignment that count toward your final grade. 266 | 267 | | Evaluation Criterion | Classification (Acc) | Segmentation (mIoU) | Auto-Encoding (CD) | 268 | |---|---|---|---| 269 | | **Success Condition \(100%\)** | 0.85 | 0.80 | 0.005 | 270 | | **Success Condition \(50%)** | 0.55 | 0.60 | 0.030 | 271 | 272 | As shown in the table above, each evaluation metric is assigned up to 10 points. In particular, 273 | - **Classification (Task 1)** 274 | - You will receive 10 points if the reported value is equal to or, *greater* than the success condition \(100%)\; 275 | - Otherwise, you will receive 5 points if the reported value is equal to or, *greater* than the success condition \(50%)\. 276 | - **Segmentation (Task 2)** 277 | - You will receive 10 points if the reported value is equal to or, *greater* than the success condition \(100%)\; 278 | - Otherwise, you will receive 5 points if the reported value is equal to or, *greater* than the success condition \(50%)\. 279 | - **Auto-Encoding (Task 3)** 280 | - You will receive 10 points if the reported value is equal to or, *less* than the success condition \(100%)\; 281 | - Otherwise, you will receive 5 points if the reported value is equal to or, *less* than the success condition \(50%)\. 282 | 283 | ## Further Readings 284 | 285 | If you are interested in this topic, we encourage you to check out the papers listed below. 286 | 287 | - PointNet++: Learning Deep Hierarchical Features from Point Sets in a Metric Space (NeurIPS 2017) 288 | - Dynamic Graph CNN for Learning on Point Clouds (TOG 2019) 289 | - PointConv: Deep Convolutional Networks on 3D Point Clouds (CVPR 2019) 290 | - PointWeb: Enhancing Local Neighborhood Features for Point Cloud Processing (CVPR 2019) 291 | - KPConv: Flexible and Deformable Convolution for Point Clouds (ICCV 2019) 292 | - PointNeXt: Revisiting PointNet++ with Improved Training and Scaling Strategies (NeurIPS 2022) 293 | - PointMLP: Rethinking Network Design and Local Geometry in Point Cloud: A Simple Residual MLP Framework (ICLR 2022) 294 | - Parameter is Not All You Need: Starting from Non-Parametric Networks for 3D Point Cloud Analysis (CVPR 2023) 295 | -------------------------------------------------------------------------------- /pointnet/visualization.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "id": "1dbf6dfa-bef2-4ad8-a5aa-ffa2fcc4923d", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "The autoreload extension is already loaded. To reload it, use:\n", 14 | " %reload_ext autoreload\n" 15 | ] 16 | } 17 | ], 18 | "source": [ 19 | "import torch\n", 20 | "from dataloaders.shapenet_partseg import ShapeNetPartSegDataset\n", 21 | "import numpy as np\n", 22 | "import matplotlib.pyplot as plt\n", 23 | "\n", 24 | "%load_ext autoreload\n", 25 | "%autoreload 2" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 3, 31 | "id": "db3081a4-03a0-43e5-ae50-3235b2f836fc", 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "ds = ShapeNetPartSegDataset('train', 'data')" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 4, 41 | "id": "ef8d6a34-10a9-47c8-8745-80ccbb53cb26", 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "def vis_pc(pc, label=None):\n", 46 | " \"\"\"\n", 47 | " pc: numpy [num_points, 3]\n", 48 | " label: Optional(numpy) [num_points]\n", 49 | " \"\"\"\n", 50 | " \n", 51 | " # normalize pc\n", 52 | " m = pc.mean(0)\n", 53 | " pc = pc - m\n", 54 | " s = np.max(np.sqrt(np.sum(pc**2, -1)))\n", 55 | " pc = pc / s\n", 56 | " \n", 57 | " fig = plt.figure(figsize=(5,5))\n", 58 | " ax = fig.add_subplot(111, projection=\"3d\")\n", 59 | " \n", 60 | " if label is not None:\n", 61 | " ax.scatter(pc[:,0], pc[:,2], pc[:,1], c=label)\n", 62 | " else:\n", 63 | " ax.scatter(pc[:,0], pc[:,2], pc[:,1])\n", 64 | " \n", 65 | " # set the range of axes\n", 66 | " ax.set_xlim(-.7,.7)\n", 67 | " ax.set_ylim(-.7,.7)\n", 68 | " ax.set_zlim(-.7,.7) \n", 69 | " \n", 70 | " # set the view point\n", 71 | " ax.view_init(elev=30, azim=150)\n", 72 | " \n", 73 | " # turn off the axes\n", 74 | " # ax.axis(\"off\")\n", 75 | " " 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 5, 81 | "id": "c46dfa0c-889c-40f9-9219-fe01237a7f42", 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "image/png": "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\n", 87 | "text/plain": [ 88 | "
" 89 | ] 90 | }, 91 | "metadata": { 92 | "needs_background": "light" 93 | }, 94 | "output_type": "display_data" 95 | } 96 | ], 97 | "source": [ 98 | "idx = 0\n", 99 | "pc, plabel, clabel = ds[idx]\n", 100 | "pc = pc.numpy(); plabel = plabel.numpy()\n", 101 | "vis_pc(pc, plabel)" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 6, 107 | "id": "46d001cd-d6ac-4812-8ed3-2446ca1c7813", 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "data": { 112 | "image/png": "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\n", 113 | "text/plain": [ 114 | "
" 115 | ] 116 | }, 117 | "metadata": { 118 | "needs_background": "light" 119 | }, 120 | "output_type": "display_data" 121 | } 122 | ], 123 | "source": [ 124 | "idx = 1\n", 125 | "pc, plabel, clabel = ds[idx]\n", 126 | "pc = pc.numpy(); plabel = plabel.numpy()\n", 127 | "vis_pc(pc, plabel)" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": 7, 133 | "id": "39f2bb7e-ef63-406b-8860-66de27a0bea9", 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "data": { 138 | "image/png": "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\n", 139 | "text/plain": [ 140 | "
" 141 | ] 142 | }, 143 | "metadata": { 144 | "needs_background": "light" 145 | }, 146 | "output_type": "display_data" 147 | } 148 | ], 149 | "source": [ 150 | "idx = 10\n", 151 | "pc, plabel, clabel = ds[idx]\n", 152 | "pc = pc.numpy(); plabel = plabel.numpy()\n", 153 | "vis_pc(pc, plabel)" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "id": "bde5bda9-4a48-47f6-8320-0f91f1a16369", 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [] 163 | } 164 | ], 165 | "metadata": { 166 | "kernelspec": { 167 | "display_name": "Python 3 (ipykernel)", 168 | "language": "python", 169 | "name": "python3" 170 | }, 171 | "language_info": { 172 | "codemirror_mode": { 173 | "name": "ipython", 174 | "version": 3 175 | }, 176 | "file_extension": ".py", 177 | "mimetype": "text/x-python", 178 | "name": "python", 179 | "nbconvert_exporter": "python", 180 | "pygments_lexer": "ipython3", 181 | "version": "3.8.0" 182 | } 183 | }, 184 | "nbformat": 4, 185 | "nbformat_minor": 5 186 | } 187 | --------------------------------------------------------------------------------