devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Windows系统保姆级复现Pointnet++算法教程笔记（基于Pytorch）_pointnet++复现

作者：我家自动化 | 2024-05-01 14:07:34

赞

踩

pointnet++复现

前言

今天复现了PointNet++网络，中途也遇到过好多报错问题，但都一一解决了，最终实现cls、partseg、semseg训练(train)和测试(test)程序的成功跑通。

首先，我参考的论文和所用的源码参考自这篇文章：

3D点云目标检测算法Pointnet++项目实战 Pytorch实现

附代码：

链接：https://pan.baidu.com/s/10Nk4Zd3S_NklY5PJwzmnWA 
提取码：6688 

论文链接：

https://proceedings.neurips.cc/paper/2017/file/d8bf84be3800d12f74d8b05e9b89836f-Paper.pdf

一、配置环境

按理说复现Pointnet的源码是适用于在Ubuntu下跑，但是我想在Windows实现一下

Windows系统

python 3.8   cuda 11.6 pytorch 1.12.0  torchvision 0.13.0

在这之前要先在anaconda下创建一个pointnet的虚拟环境，python版本选择3.8

  1. # 创建虚拟环境
  2. conda create -n pointnet python=3.8.0
  3. # 激活虚拟环境(切换至这个环境)
  4. conda activate pointnet
  5. # 查看已创建的虚拟环境
  6. conda info -e

然后对应自己CUDA版本下载对应的gpu版的pytorch

  1. # CUDA 11.6
  2. pip install torch==1.13.1+cu116 torchvision==0.14.1+cu116 torchaudio==0.13.1 --extra-index-url https://download.pytorch.org/whl/cu116

这一块虚拟环境的GPU配置就不细说了，如果没有配置过可以参考我这篇文章，基本步骤都差不多：

YOLOv8目标跟踪环境配置笔记（完整记录一次成功）

二、复现步骤

1.先将代码下载下来，目录结构如下：
 

其实这里的东西如果真的想全部能跑是缺了一些东西的，下面具体再说。

2.启动PyCharm打开该项目文件Pointnet2，同时将自己前面创建好的虚拟环境导入进来（具体导入的方法，参考我上面的文章链接，也有步骤）

其中环境Python3.8是自己给虚拟环境起的名称，可以在这里面编辑，因为我前面配置过Python3.7的虚拟环境，而这次采用pythonn3.8版本的，一开始导入进来，前面的环境名称还是默认Python3.7，我以为3.8版本的python编译器没有成功导入进来，担心后面因版本问题引起不必要的报错，后来发现编译器python.exe已经是3.8的了，只是虚拟环境名称需要改一下

如果不确定可以跑下面的程序来确认一下python版本（确认一下导入的虚拟环境是对的）

  1. import sys
  2. print(sys.version)

3.接下来我们就可以依次运行train_cls.py、train_partseg.py、train_semseg.py、test_cls.py、test_partseg.py、test_semseg.py是否可以正常跑通，train代表进行模型训练用的，test代表模型测试用的。

首先我把我自己调通的可以跑的程序先放出来

（1）train_cls.py

  1. from data_utils.ModelNetDataLoader import ModelNetDataLoader
  2. import argparse
  3. import numpy as np
  4. import os
  5. import torch
  6. import datetime
  7. import logging
  8. from pathlib import Path
  9. from tqdm import tqdm
  10. import sys
  11. import provider
  12. import importlib
  13. import shutil
  14.  
  15. BASE_DIR = os.path.dirname(os.path.abspath(__file__))
  16. ROOT_DIR = BASE_DIR
  17. sys.path.append(os.path.join(ROOT_DIR, 'models'))
  18. """
  19. 需要配置的参数：
  20. --model pointnet2_cls_msg 
  21. --normal 
  22. --log_dir pointnet2_cls_msg
  23. """
  24.  
  25. def parse_args():
  26.     '''PARAMETERS'''
  27.     parser = argparse.ArgumentParser('PointNet')
  28.     parser.add_argument('--batch_size', type=int, default=8, help='batch size in training [default: 24]')
  29.     parser.add_argument('--model', default='pointnet2_cls_ssg', help='model name [default: pointnet_cls]')
  30.     parser.add_argument('--epoch',  default=200, type=int, help='number of epoch in training [default: 200]')
  31.     parser.add_argument('--learning_rate', default=0.001, type=float, help='learning rate in training [default: 0.001]')
  32.     parser.add_argument('--gpu', type=str, default='0', help='specify gpu device [default: 0]')
  33.     parser.add_argument('--num_point', type=int, default=1024, help='Point Number [default: 1024]')
  34.     parser.add_argument('--optimizer', type=str, default='Adam', help='optimizer for training [default: Adam]')
  35.     parser.add_argument('--log_dir', type=str, default=None, help='experiment root')
  36.     parser.add_argument('--decay_rate', type=float, default=1e-4, help='decay rate [default: 1e-4]')
  37.     parser.add_argument('--normal', action='store_true', default=False, help='Whether to use normal information [default: False]')
  38.     return parser.parse_args()
  39.  
  40. def test(model, loader, num_class=40):
  41.     mean_correct = []
  42.     class_acc = np.zeros((num_class,3))
  43.     for j, data in tqdm(enumerate(loader), total=len(loader)):
  44.         points, target = data
  45.         target = target[:, 0]
  46.         points = points.transpose(2, 1)
  47.         points, target = points.cuda(), target.cuda()
  48.         classifier = model.eval()
  49.         pred, _ = classifier(points)
  50.         pred_choice = pred.data.max(1)[1]
  51.         for cat in np.unique(target.cpu()):
  52.             classacc = pred_choice[target==cat].eq(target[target==cat].long().data).cpu().sum()
  53.             class_acc[cat,0]+= classacc.item()/float(points[target==cat].size()[0])
  54.             class_acc[cat,1]+=1
  55.         correct = pred_choice.eq(target.long().data).cpu().sum()
  56.         mean_correct.append(correct.item()/float(points.size()[0]))
  57.     class_acc[:,2] =  class_acc[:,0]/ class_acc[:,1]
  58.     class_acc = np.mean(class_acc[:,2])
  59.     instance_acc = np.mean(mean_correct)
  60.     return instance_acc, class_acc
  61.  
  62.  
  63. def main(args):
  64.     def log_string(str):
  65.         logger.info(str)
  66.         print(str)
  67.  
  68.     '''HYPER PARAMETER'''
  69.     os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
  70.  
  71.     '''CREATE DIR'''
  72.     #创建文件夹
  73.     timestr = str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M'))
  74.     experiment_dir = Path('./log/')
  75.     experiment_dir.mkdir(exist_ok=True)
  76.     experiment_dir = experiment_dir.joinpath('classification')
  77.     experiment_dir.mkdir(exist_ok=True)
  78.     if args.log_dir is None:
  79.         experiment_dir = experiment_dir.joinpath(timestr)
  80.     else:
  81.         experiment_dir = experiment_dir.joinpath(args.log_dir)
  82.     experiment_dir.mkdir(exist_ok=True)
  83.     checkpoints_dir = experiment_dir.joinpath('checkpoints/')
  84.     checkpoints_dir.mkdir(exist_ok=True)
  85.     log_dir = experiment_dir.joinpath('logs/')
  86.     log_dir.mkdir(exist_ok=True)
  87.  
  88.     '''LOG'''
  89.     args = parse_args()
  90.     logger = logging.getLogger("Model")
  91.     logger.setLevel(logging.INFO)
  92.     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  93.     file_handler = logging.FileHandler('%s/%s.txt' % (log_dir, args.model))
  94.     file_handler.setLevel(logging.INFO)
  95.     file_handler.setFormatter(formatter)
  96.     logger.addHandler(file_handler)
  97.     log_string('PARAMETER ...')
  98.     log_string(args)
  99.  
  100.     '''DATA LOADING'''
  101.     log_string('Load dataset ...')
  102.     DATA_PATH = 'data/modelnet40_normal_resampled/'
  103.  
  104.     TRAIN_DATASET = ModelNetDataLoader(root=DATA_PATH, npoint=args.num_point, split='train',
  105.                                                      normal_channel=args.normal)
  106.     TEST_DATASET = ModelNetDataLoader(root=DATA_PATH, npoint=args.num_point, split='test',
  107.                                                     normal_channel=args.normal)
  108.     trainDataLoader = torch.utils.data.DataLoader(TRAIN_DATASET, batch_size=args.batch_size, shuffle=True, num_workers=4)
  109.     testDataLoader = torch.utils.data.DataLoader(TEST_DATASET, batch_size=args.batch_size, shuffle=False, num_workers=4)
  110.  
  111.     '''MODEL LOADING'''
  112.     num_class = 40
  113.     MODEL = importlib.import_module(args.model)
  114.     shutil.copy('./models/%s.py' % args.model, str(experiment_dir))
  115.     shutil.copy('./models/pointnet_util.py', str(experiment_dir))
  116.  
  117.     classifier = MODEL.get_model(num_class,normal_channel=args.normal).cuda()
  118.     criterion = MODEL.get_loss().cuda()
  119.  
  120.     try:
  121.         checkpoint = torch.load(str(experiment_dir) + '/checkpoints/best_model.pth')
  122.         start_epoch = checkpoint['epoch']
  123.         classifier.load_state_dict(checkpoint['model_state_dict'])
  124.         log_string('Use pretrain model')
  125.     except:
  126.         log_string('No existing model, starting training from scratch...')
  127.         start_epoch = 0
  128.  
  129.  
  130.     if args.optimizer == 'Adam':
  131.         optimizer = torch.optim.Adam(
  132.             classifier.parameters(),
  133.             lr=args.learning_rate,
  134.             betas=(0.9, 0.999),
  135.             eps=1e-08,
  136.             weight_decay=args.decay_rate
  137.         )
  138.     else:
  139.         optimizer = torch.optim.SGD(classifier.parameters(), lr=0.01, momentum=0.9)
  140.  
  141.     scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.7)
  142.     global_epoch = 0
  143.     global_step = 0
  144.     best_instance_acc = 0.0
  145.     best_class_acc = 0.0
  146.     mean_correct = []
  147.  
  148.     '''TRANING'''
  149.     logger.info('Start training...')
  150.     for epoch in range(start_epoch,args.epoch):
  151.         log_string('Epoch %d (%d/%s):' % (global_epoch + 1, epoch + 1, args.epoch))
  152.         # optimizer.step()通常用在每个mini-batch之中，而scheduler.step()通常用在epoch里面,
  153.         # 但也不是绝对的，可以根据具体的需求来做。
  154.         # 只有用了optimizer.step()，模型才会更新，而scheduler.step()是对lr进行调整。
  155.         scheduler.step()
  156.         for batch_id, data in tqdm(enumerate(trainDataLoader, 0), total=len(trainDataLoader), smoothing=0.9):
  157.             points, target = data
  158.             points = points.data.numpy()
  159.             points = provider.random_point_dropout(points) #进行数据增强
  160.             points[:,:, 0:3] = provider.random_scale_point_cloud(points[:,:, 0:3]) #在数值上调大或调小，设置一个范围
  161.             points[:,:, 0:3] = provider.shift_point_cloud(points[:,:, 0:3]) #增加随机抖动，使测试结果更好
  162.             points = torch.Tensor(points)
  163.             target = target[:, 0]
  164.  
  165.             points = points.transpose(2, 1)
  166.             points, target = points.cuda(), target.cuda()
  167.             optimizer.zero_grad()
  168.  
  169.             classifier = classifier.train()
  170.             pred, trans_feat = classifier(points)
  171.             loss = criterion(pred, target.long(), trans_feat) #计算损失
  172.             pred_choice = pred.data.max(1)[1]
  173.             correct = pred_choice.eq(target.long().data).cpu().sum()
  174.             mean_correct.append(correct.item() / float(points.size()[0]))
  175.             loss.backward() #反向传播
  176.             optimizer.step() #最好的测试结果
  177.             global_step += 1
  178.  
  179.         train_instance_acc = np.mean(mean_correct)
  180.         log_string('Train Instance Accuracy: %f' % train_instance_acc)
  181.  
  182.         with torch.no_grad():
  183.             instance_acc, class_acc = test(classifier.eval(), testDataLoader)
  184.  
  185.             if (instance_acc >= best_instance_acc):
  186.                 best_instance_acc = instance_acc
  187.                 best_epoch = epoch + 1
  188.  
  189.             if (class_acc >= best_class_acc):
  190.                 best_class_acc = class_acc
  191.             log_string('Test Instance Accuracy: %f, Class Accuracy: %f'% (instance_acc, class_acc))
  192.             log_string('Best Instance Accuracy: %f, Class Accuracy: %f'% (best_instance_acc, best_class_acc))
  193.  
  194.             if (instance_acc >= best_instance_acc):
  195.                 logger.info('Save model...')
  196.                 savepath = str(checkpoints_dir) + '/best_model.pth'
  197.                 log_string('Saving at %s'% savepath)
  198.                 state = {
  199.                     'epoch': best_epoch,
  200.                     'instance_acc': instance_acc,
  201.                     'class_acc': class_acc,
  202.                     'model_state_dict': classifier.state_dict(),
  203.                     'optimizer_state_dict': optimizer.state_dict(),
  204.                 }
  205.                 torch.save(state, savepath)
  206.             global_epoch += 1
  207.  
  208.     logger.info('End of training...')
  209.  
  210. if __name__ == '__main__':
  211.     args = parse_args()
  212.     main(args)

（2）train_partseg.py

  1. import argparse
  2. import os
  3. from data_utils.ShapeNetDataLoader import PartNormalDataset
  4. import torch
  5. import datetime
  6. import logging
  7. from pathlib import Path
  8. import sys
  9. import importlib
  10. import shutil
  11. from tqdm import tqdm
  12. import provider
  13. import numpy as np
  14. """
  15. 训练所需设置参数：
  16. --model pointnet2_part_seg_msg 
  17. --normal 
  18. --log_dir pointnet2_part_seg_msg
  19. """
  20.  
  21. BASE_DIR = os.path.dirname(os.path.abspath(__file__))
  22. ROOT_DIR = BASE_DIR
  23. sys.path.append(os.path.join(ROOT_DIR, 'models'))
  24.  
  25. #各个物体部件的编号
  26. seg_classes = {'Earphone': [16, 17, 18], 'Motorbike': [30, 31, 32, 33, 34, 35], 'Rocket': [41, 42, 43], 'Car': [8, 9, 10, 11], 'Laptop': [28, 29], 'Cap': [6, 7], 'Skateboard': [44, 45, 46], 'Mug': [36, 37], 'Guitar': [19, 20, 21], 'Bag': [4, 5], 'Lamp': [24, 25, 26, 27], 'Table': [47, 48, 49], 'Airplane': [0, 1, 2, 3], 'Pistol': [38, 39, 40], 'Chair': [12, 13, 14, 15], 'Knife': [22, 23]}
  27. seg_label_to_cat = {} # {0:Airplane, 1:Airplane, ...49:Table}
  28. for cat in seg_classes.keys():
  29.     for label in seg_classes[cat]:
  30.         seg_label_to_cat[label] = cat
  31.  
  32. def to_categorical(y, num_classes):
  33.     """ 1-hot encodes a tensor """
  34.     new_y = torch.eye(num_classes)[y.cpu().data.numpy(),]
  35.     if (y.is_cuda):
  36.         return new_y.cuda()
  37.     return new_y
  38.  
  39. def parse_args():
  40.     parser = argparse.ArgumentParser('Model')
  41.     parser.add_argument('--model', type=str, default='pointnet2_part_seg_msg', help='model name [default: pointnet2_part_seg_msg]')
  42.     parser.add_argument('--batch_size', type=int, default=32, help='Batch Size during training [default: 16]')
  43.     parser.add_argument('--epoch',  default=2, type=int, help='Epoch to run [default: 251]')
  44.     parser.add_argument('--learning_rate', default=0.001, type=float, help='Initial learning rate [default: 0.001]')
  45.     # parser.add_argument('--gpu', type=str, default='', help='GPU to use [default: GPU 0]')
  46.     parser.add_argument('--gpu', default='', help='cuda gpu, i.e. 0 or 0,1,2,3 or cpu')
  47.     parser.add_argument('--optimizer', type=str, default='Adam', help='Adam or SGD [default: Adam]')
  48.     parser.add_argument('--log_dir', type=str, default=None, help='Log path [default: None]')
  49.     parser.add_argument('--decay_rate', type=float, default=1e-4, help='weight decay [default: 1e-4]')
  50.     parser.add_argument('--npoint', type=int,  default=2048, help='Point Number [default: 2048]')
  51.     parser.add_argument('--normal', action='store_true', default=False, help='Whether to use normal information [default: False]')
  52.     parser.add_argument('--step_size', type=int,  default=20, help='Decay step for lr decay [default: every 20 epochs]')
  53.     parser.add_argument('--lr_decay', type=float,  default=0.5, help='Decay rate for lr decay [default: 0.5]')
  54.  
  55.     return parser.parse_args()
  56.  
  57. def main(args):
  58.     def log_string(str):
  59.         logger.info(str)
  60.         print(str)
  61.  
  62.     '''HYPER PARAMETER'''
  63.     os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
  64.  
  65.     '''CREATE DIR'''
  66.     timestr = str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M'))
  67.     experiment_dir = Path('./log/')
  68.     experiment_dir.mkdir(exist_ok=True)
  69.     experiment_dir = experiment_dir.joinpath('part_seg')
  70.     experiment_dir.mkdir(exist_ok=True)
  71.     if args.log_dir is None:
  72.         experiment_dir = experiment_dir.joinpath(timestr)
  73.     else:
  74.         experiment_dir = experiment_dir.joinpath(args.log_dir)
  75.     experiment_dir.mkdir(exist_ok=True)
  76.     checkpoints_dir = experiment_dir.joinpath('checkpoints/')
  77.     checkpoints_dir.mkdir(exist_ok=True)
  78.     log_dir = experiment_dir.joinpath('logs/')
  79.     log_dir.mkdir(exist_ok=True)
  80.  
  81.     '''LOG'''
  82.     args = parse_args()
  83.     logger = logging.getLogger("Model")
  84.     logger.setLevel(logging.INFO)
  85.     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  86.     file_handler = logging.FileHandler('%s/%s.txt' % (log_dir, args.model))
  87.     file_handler.setLevel(logging.INFO)
  88.     file_handler.setFormatter(formatter)
  89.     logger.addHandler(file_handler)
  90.     log_string('PARAMETER ...')
  91.     log_string(args)
  92.  
  93.     root = 'data/shapenetcore_partanno_segmentation_benchmark_v0_normal/'
  94.  
  95.     TRAIN_DATASET = PartNormalDataset(root = root, npoints=args.npoint, split='trainval', normal_channel=args.normal)
  96.     trainDataLoader = torch.utils.data.DataLoader(TRAIN_DATASET, batch_size=args.batch_size,shuffle=True, num_workers=4)
  97.     TEST_DATASET = PartNormalDataset(root = root, npoints=args.npoint, split='test', normal_channel=args.normal)
  98.     testDataLoader = torch.utils.data.DataLoader(TEST_DATASET, batch_size=args.batch_size,shuffle=False, num_workers=4)
  99.     log_string("The number of training data is: %d" % len(TRAIN_DATASET))
  100.     log_string("The number of test data is: %d" %  len(TEST_DATASET))
  101.     num_classes = 16
  102.     num_part = 50
  103.     '''MODEL LOADING'''
  104.     MODEL = importlib.import_module(args.model)
  105.     shutil.copy('models/%s.py' % args.model, str(experiment_dir))
  106.     shutil.copy('models/pointnet_util.py', str(experiment_dir))
  107.  
  108.     classifier = MODEL.get_model(num_part, normal_channel=args.normal).cuda()
  109.     criterion = MODEL.get_loss().cuda()
  110.  
  111.  
  112.     def weights_init(m):
  113.         classname = m.__class__.__name__
  114.         if classname.find('Conv2d') != -1:
  115.             torch.nn.init.xavier_normal_(m.weight.data)
  116.             torch.nn.init.constant_(m.bias.data, 0.0)
  117.         elif classname.find('Linear') != -1:
  118.             torch.nn.init.xavier_normal_(m.weight.data)
  119.             torch.nn.init.constant_(m.bias.data, 0.0)
  120.  
  121.     try:
  122.         checkpoint = torch.load(str(experiment_dir) + '/checkpoints/best_model.pth')#log/part_seg/pointnet2_part_seg_msg/checkpoints/best_model.pth
  123.         start_epoch = checkpoint['epoch']
  124.         classifier.load_state_dict(checkpoint['model_state_dict'])
  125.         log_string('Use pretrain model')
  126.     except:
  127.         log_string('No existing model, starting training from scratch...')
  128.         start_epoch = 0
  129.         classifier = classifier.apply(weights_init)
  130.  
  131.     if args.optimizer == 'Adam':
  132.         optimizer = torch.optim.Adam(
  133.             classifier.parameters(),
  134.             lr=args.learning_rate,
  135.             betas=(0.9, 0.999),
  136.             eps=1e-08,
  137.             weight_decay=args.decay_rate
  138.         )
  139.     else:
  140.         optimizer = torch.optim.SGD(classifier.parameters(), lr=args.learning_rate, momentum=0.9)
  141.  
  142.     def bn_momentum_adjust(m, momentum):
  143.         if isinstance(m, torch.nn.BatchNorm2d) or isinstance(m, torch.nn.BatchNorm1d):
  144.             m.momentum = momentum
  145.  
  146.     LEARNING_RATE_CLIP = 1e-5
  147.     MOMENTUM_ORIGINAL = 0.1
  148.     MOMENTUM_DECCAY = 0.5
  149.     MOMENTUM_DECCAY_STEP = args.step_size
  150.  
  151.     best_acc = 0
  152.     global_epoch = 0
  153.     best_class_avg_iou = 0
  154.     best_inctance_avg_iou = 0
  155.  
  156.     for epoch in range(start_epoch,args.epoch):
  157.         log_string('Epoch %d (%d/%s):' % (global_epoch + 1, epoch + 1, args.epoch))
  158.         '''Adjust learning rate and BN momentum'''
  159.         lr = max(args.learning_rate * (args.lr_decay ** (epoch // args.step_size)), LEARNING_RATE_CLIP)
  160.         log_string('Learning rate:%f' % lr)
  161.         for param_group in optimizer.param_groups:
  162.             param_group['lr'] = lr
  163.         mean_correct = []
  164.         momentum = MOMENTUM_ORIGINAL * (MOMENTUM_DECCAY ** (epoch // MOMENTUM_DECCAY_STEP))
  165.         if momentum < 0.01:
  166.             momentum = 0.01
  167.         print('BN momentum updated to: %f' % momentum)
  168.         classifier = classifier.apply(lambda x: bn_momentum_adjust(x,momentum))
  169.  
  170.         '''learning one epoch'''
  171.         for i, data in tqdm(enumerate(trainDataLoader), total=len(trainDataLoader), smoothing=0.9):
  172.             points, label, target = data
  173.             points = points.data.numpy()
  174.             points[:,:, 0:3] = provider.random_scale_point_cloud(points[:,:, 0:3])
  175.             points[:,:, 0:3] = provider.shift_point_cloud(points[:,:, 0:3])
  176.             points = torch.Tensor(points)
  177.             points, label, target = points.float().cuda(),label.long().cuda(), target.long().cuda()
  178.             points = points.transpose(2, 1)
  179.             optimizer.zero_grad()
  180.             classifier = classifier.train()
  181.             seg_pred, trans_feat = classifier(points, to_categorical(label, num_classes))
  182.             seg_pred = seg_pred.contiguous().view(-1, num_part)
  183.             target = target.view(-1, 1)[:, 0]
  184.             pred_choice = seg_pred.data.max(1)[1]
  185.             correct = pred_choice.eq(target.data).cpu().sum()
  186.             mean_correct.append(correct.item() / (args.batch_size * args.npoint))
  187.             loss = criterion(seg_pred, target, trans_feat)
  188.             loss.backward()
  189.             optimizer.step()
  190.         train_instance_acc = np.mean(mean_correct)
  191.         log_string('Train accuracy is: %.5f' % train_instance_acc)
  192.  
  193.         with torch.no_grad():
  194.             test_metrics = {}
  195.             total_correct = 0
  196.             total_seen = 0
  197.             total_seen_class = [0 for _ in range(num_part)]
  198.             total_correct_class = [0 for _ in range(num_part)]
  199.             shape_ious = {cat: [] for cat in seg_classes.keys()}
  200.             seg_label_to_cat = {}  # {0:Airplane, 1:Airplane, ...49:Table}
  201.             for cat in seg_classes.keys():
  202.                 for label in seg_classes[cat]:
  203.                     seg_label_to_cat[label] = cat
  204.  
  205.             for batch_id, (points, label, target) in tqdm(enumerate(testDataLoader), total=len(testDataLoader), smoothing=0.9):
  206.                 cur_batch_size, NUM_POINT, _ = points.size()
  207.                 points, label, target = points.float().cuda(), label.long().cuda(), target.long().cuda()
  208.                 points = points.transpose(2, 1)
  209.                 classifier = classifier.eval()
  210.                 seg_pred, _ = classifier(points, to_categorical(label, num_classes))
  211.                 cur_pred_val = seg_pred.cpu().data.numpy()
  212.                 cur_pred_val_logits = cur_pred_val
  213.                 cur_pred_val = np.zeros((cur_batch_size, NUM_POINT)).astype(np.int32)
  214.                 target = target.cpu().data.numpy()
  215.                 for i in range(cur_batch_size):
  216.                     cat = seg_label_to_cat[target[i, 0]]
  217.                     logits = cur_pred_val_logits[i, :, :]
  218.                     cur_pred_val[i, :] = np.argmax(logits[:, seg_classes[cat]], 1) + seg_classes[cat][0]
  219.                 correct = np.sum(cur_pred_val == target)
  220.                 total_correct += correct
  221.                 total_seen += (cur_batch_size * NUM_POINT)
  222.  
  223.                 for l in range(num_part):
  224.                     total_seen_class[l] += np.sum(target == l)
  225.                     total_correct_class[l] += (np.sum((cur_pred_val == l) & (target == l)))
  226.  
  227.                 for i in range(cur_batch_size):
  228.                     segp = cur_pred_val[i, :]
  229.                     segl = target[i, :]
  230.                     cat = seg_label_to_cat[segl[0]]
  231.                     part_ious = [0.0 for _ in range(len(seg_classes[cat]))]
  232.                     for l in seg_classes[cat]:
  233.                         if (np.sum(segl == l) == 0) and (
  234.                                 np.sum(segp == l) == 0):  # part is not present, no prediction as well
  235.                             part_ious[l - seg_classes[cat][0]] = 1.0
  236.                         else:
  237.                             part_ious[l - seg_classes[cat][0]] = np.sum((segl == l) & (segp == l)) / float(
  238.                                 np.sum((segl == l) | (segp == l)))
  239.                     shape_ious[cat].append(np.mean(part_ious))
  240.  
  241.             all_shape_ious = []
  242.             for cat in shape_ious.keys():
  243.                 for iou in shape_ious[cat]:
  244.                     all_shape_ious.append(iou)
  245.                 shape_ious[cat] = np.mean(shape_ious[cat])
  246.             mean_shape_ious = np.mean(list(shape_ious.values()))
  247.             test_metrics['accuracy'] = total_correct / float(total_seen)
  248.             test_metrics['class_avg_accuracy'] = np.mean(
  249.                 np.array(total_correct_class) / np.array(total_seen_class, dtype=np.float))
  250.             for cat in sorted(shape_ious.keys()):
  251.                 log_string('eval mIoU of %s %f' % (cat + ' ' * (14 - len(cat)), shape_ious[cat]))
  252.             test_metrics['class_avg_iou'] = mean_shape_ious
  253.             test_metrics['inctance_avg_iou'] = np.mean(all_shape_ious)
  254.  
  255.  
  256.         log_string('Epoch %d test Accuracy: %f  Class avg mIOU: %f   Inctance avg mIOU: %f' % (
  257.                  epoch+1, test_metrics['accuracy'],test_metrics['class_avg_iou'],test_metrics['inctance_avg_iou']))
  258.         if (test_metrics['inctance_avg_iou'] >= best_inctance_avg_iou):
  259.             logger.info('Save model...')
  260.             savepath = str(checkpoints_dir) + '/best_model.pth'
  261.             log_string('Saving at %s'% savepath)
  262.             state = {
  263.                 'epoch': epoch,
  264.                 'train_acc': train_instance_acc,
  265.                 'test_acc': test_metrics['accuracy'],
  266.                 'class_avg_iou': test_metrics['class_avg_iou'],
  267.                 'inctance_avg_iou': test_metrics['inctance_avg_iou'],
  268.                 'model_state_dict': classifier.state_dict(),
  269.                 'optimizer_state_dict': optimizer.state_dict(),
  270.             }
  271.             torch.save(state, savepath)
  272.             log_string('Saving model....')
  273.  
  274.         if test_metrics['accuracy'] > best_acc:
  275.             best_acc = test_metrics['accuracy']
  276.         if test_metrics['class_avg_iou'] > best_class_avg_iou:
  277.             best_class_avg_iou = test_metrics['class_avg_iou']
  278.         if test_metrics['inctance_avg_iou'] > best_inctance_avg_iou:
  279.             best_inctance_avg_iou = test_metrics['inctance_avg_iou']
  280.         log_string('Best accuracy is: %.5f'%best_acc)
  281.         log_string('Best class avg mIOU is: %.5f'%best_class_avg_iou)
  282.         log_string('Best inctance avg mIOU is: %.5f'%best_inctance_avg_iou)
  283.         global_epoch+=1
  284.  
  285. if __name__ == '__main__':
  286.     args = parse_args()
  287.     main(args)
  288.

（3）train_semseg.py

  1. """
  2. Author: Benny
  3. Date: Nov 2019
  4. """
  5. import argparse
  6. import os
  7. from data_utils.S3DISDataLoader import S3DISDataset
  8. import torch
  9. import datetime
  10. import logging
  11. from pathlib import Path
  12. import sys
  13. import importlib
  14. import shutil
  15. from tqdm import tqdm
  16. import provider
  17. import numpy as np
  18. import time
  19.  
  20. BASE_DIR = os.path.dirname(os.path.abspath(__file__))
  21. ROOT_DIR = BASE_DIR
  22. sys.path.append(os.path.join(ROOT_DIR, 'models'))
  23.  
  24.  
  25. classes = ['ceiling','floor','wall','beam','column','window','door','table','chair','sofa','bookcase','board','clutter']
  26. class2label = {cls: i for i,cls in enumerate(classes)}
  27. seg_classes = class2label
  28. seg_label_to_cat = {}
  29. for i,cat in enumerate(seg_classes.keys()):
  30.     seg_label_to_cat[i] = cat
  31.  
  32.  
  33. def parse_args():
  34.     parser = argparse.ArgumentParser('Model')
  35.     parser.add_argument('--model', type=str, default='pointnet_sem_seg', help='model name [default: pointnet_sem_seg]')
  36.     parser.add_argument('--batch_size', type=int, default=16, help='Batch Size during training [default: 16]')
  37.     parser.add_argument('--epoch',  default=128, type=int, help='Epoch to run [default: 128]')
  38.     parser.add_argument('--learning_rate', default=0.001, type=float, help='Initial learning rate [default: 0.001]')
  39.     parser.add_argument('--gpu', type=str, default='0', help='GPU to use [default: GPU 0]')
  40.     parser.add_argument('--optimizer', type=str, default='Adam', help='Adam or SGD [default: Adam]')
  41.     parser.add_argument('--log_dir', type=str, default=None, help='Log path [default: None]')
  42.     parser.add_argument('--decay_rate', type=float, default=1e-4, help='weight decay [default: 1e-4]')
  43.     parser.add_argument('--npoint', type=int,  default=4096, help='Point Number [default: 4096]')
  44.     parser.add_argument('--step_size', type=int,  default=10, help='Decay step for lr decay [default: every 10 epochs]')
  45.     parser.add_argument('--lr_decay', type=float,  default=0.7, help='Decay rate for lr decay [default: 0.7]')
  46.     parser.add_argument('--test_area', type=int, default=5, help='Which area to use for test, option: 1-6 [default: 5]')
  47.  
  48.     return parser.parse_args()
  49.  
  50. def main(args):
  51.     def log_string(str):
  52.         logger.info(str)
  53.         print(str)
  54.  
  55.     '''HYPER PARAMETER'''
  56.     os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
  57.  
  58.     '''CREATE DIR'''
  59.     timestr = str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M'))
  60.     experiment_dir = Path('./log/')
  61.     experiment_dir.mkdir(exist_ok=True)
  62.     experiment_dir = experiment_dir.joinpath('sem_seg')
  63.     experiment_dir.mkdir(exist_ok=True)
  64.     if args.log_dir is None:
  65.         experiment_dir = experiment_dir.joinpath(timestr)
  66.     else:
  67.         experiment_dir = experiment_dir.joinpath(args.log_dir)
  68.     experiment_dir.mkdir(exist_ok=True)
  69.     checkpoints_dir = experiment_dir.joinpath('checkpoints/')
  70.     checkpoints_dir.mkdir(exist_ok=True)
  71.     log_dir = experiment_dir.joinpath('logs/')
  72.     log_dir.mkdir(exist_ok=True)
  73.  
  74.     '''LOG'''
  75.     args = parse_args()
  76.     logger = logging.getLogger("Model")
  77.     logger.setLevel(logging.INFO)
  78.     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  79.     file_handler = logging.FileHandler('%s/%s.txt' % (log_dir, args.model))
  80.     file_handler.setLevel(logging.INFO)
  81.     file_handler.setFormatter(formatter)
  82.     logger.addHandler(file_handler)
  83.     log_string('PARAMETER ...')
  84.     log_string(args)
  85.  
  86.     root = 'data/stanford_indoor3d/'
  87.     NUM_CLASSES = 13
  88.     NUM_POINT = args.npoint
  89.     BATCH_SIZE = args.batch_size
  90.  
  91.     print("start loading training data ...")
  92.     TRAIN_DATASET = S3DISDataset(split='train', data_root=root, num_point=NUM_POINT, test_area=args.test_area, block_size=1.0, sample_rate=1.0, transform=None)
  93.     print("start loading test data ...")
  94.     TEST_DATASET = S3DISDataset(split='test', data_root=root, num_point=NUM_POINT, test_area=args.test_area, block_size=1.0, sample_rate=1.0, transform=None)
  95.     trainDataLoader = torch.utils.data.DataLoader(TRAIN_DATASET, batch_size=BATCH_SIZE, shuffle=True, num_workers=0, pin_memory=True, drop_last=True, worker_init_fn = lambda x: np.random.seed(x+int(time.time())))
  96.     testDataLoader = torch.utils.data.DataLoader(TEST_DATASET, batch_size=BATCH_SIZE, shuffle=False, num_workers=0, pin_memory=True, drop_last=True)
  97.     weights = torch.Tensor(TRAIN_DATASET.labelweights).cuda()
  98.  
  99.     log_string("The number of training data is: %d" % len(TRAIN_DATASET))
  100.     log_string("The number of test data is: %d" % len(TEST_DATASET))
  101.  
  102.     '''MODEL LOADING'''
  103.     MODEL = importlib.import_module(args.model)
  104.     shutil.copy('models/%s.py' % args.model, str(experiment_dir))
  105.     shutil.copy('models/pointnet_util.py', str(experiment_dir))
  106.  
  107.     classifier = MODEL.get_model(NUM_CLASSES).cuda()
  108.     criterion = MODEL.get_loss().cuda()
  109.  
  110.     def weights_init(m):
  111.         classname = m.__class__.__name__
  112.         if classname.find('Conv2d') != -1:
  113.             torch.nn.init.xavier_normal_(m.weight.data)
  114.             torch.nn.init.constant_(m.bias.data, 0.0)
  115.         elif classname.find('Linear') != -1:
  116.             torch.nn.init.xavier_normal_(m.weight.data)
  117.             torch.nn.init.constant_(m.bias.data, 0.0)
  118.  
  119.     try:
  120.         checkpoint = torch.load(str(experiment_dir) + '/checkpoints/best_model.pth')
  121.         start_epoch = checkpoint['epoch']
  122.         classifier.load_state_dict(checkpoint['model_state_dict'])
  123.         log_string('Use pretrain model')
  124.     except:
  125.         log_string('No existing model, starting training from scratch...')
  126.         start_epoch = 0
  127.         classifier = classifier.apply(weights_init)
  128.  
  129.     if args.optimizer == 'Adam':
  130.         optimizer = torch.optim.Adam(
  131.             classifier.parameters(),
  132.             lr=args.learning_rate,
  133.             betas=(0.9, 0.999),
  134.             eps=1e-08,
  135.             weight_decay=args.decay_rate
  136.         )
  137.     else:
  138.         optimizer = torch.optim.SGD(classifier.parameters(), lr=args.learning_rate, momentum=0.9)
  139.  
  140.     def bn_momentum_adjust(m, momentum):
  141.         if isinstance(m, torch.nn.BatchNorm2d) or isinstance(m, torch.nn.BatchNorm1d):
  142.             m.momentum = momentum
  143.  
  144.     LEARNING_RATE_CLIP = 1e-5
  145.     MOMENTUM_ORIGINAL = 0.1
  146.     MOMENTUM_DECCAY = 0.5
  147.     MOMENTUM_DECCAY_STEP = args.step_size
  148.  
  149.     global_epoch = 0
  150.     best_iou = 0
  151.  
  152.     for epoch in range(start_epoch,args.epoch):
  153.         '''Train on chopped scenes'''
  154.         log_string('**** Epoch %d (%d/%s) ****' % (global_epoch + 1, epoch + 1, args.epoch))
  155.         lr = max(args.learning_rate * (args.lr_decay ** (epoch // args.step_size)), LEARNING_RATE_CLIP)
  156.         log_string('Learning rate:%f' % lr)
  157.         for param_group in optimizer.param_groups:
  158.             param_group['lr'] = lr
  159.         momentum = MOMENTUM_ORIGINAL * (MOMENTUM_DECCAY ** (epoch // MOMENTUM_DECCAY_STEP))
  160.         if momentum < 0.01:
  161.             momentum = 0.01
  162.         print('BN momentum updated to: %f' % momentum)
  163.         classifier = classifier.apply(lambda x: bn_momentum_adjust(x,momentum))
  164.         num_batches = len(trainDataLoader)
  165.         total_correct = 0
  166.         total_seen = 0
  167.         loss_sum = 0
  168.         for i, data in tqdm(enumerate(trainDataLoader), total=len(trainDataLoader), smoothing=0.9):
  169.             points, target = data
  170.             points = points.data.numpy()
  171.             points[:,:, :3] = provider.rotate_point_cloud_z(points[:,:, :3])
  172.             points = torch.Tensor(points)
  173.             points, target = points.float().cuda(),target.long().cuda()
  174.             points = points.transpose(2, 1)
  175.             optimizer.zero_grad()
  176.             classifier = classifier.train()
  177.             seg_pred, trans_feat = classifier(points)
  178.             seg_pred = seg_pred.contiguous().view(-1, NUM_CLASSES)
  179.             batch_label = target.view(-1, 1)[:, 0].cpu().data.numpy()
  180.             target = target.view(-1, 1)[:, 0]
  181.             loss = criterion(seg_pred, target, trans_feat, weights)
  182.             loss.backward()
  183.             optimizer.step()
  184.             pred_choice = seg_pred.cpu().data.max(1)[1].numpy()
  185.             correct = np.sum(pred_choice == batch_label)
  186.             total_correct += correct
  187.             total_seen += (BATCH_SIZE * NUM_POINT)
  188.             loss_sum += loss
  189.         log_string('Training mean loss: %f' % (loss_sum / num_batches))
  190.         log_string('Training accuracy: %f' % (total_correct / float(total_seen)))
  191.  
  192.         if epoch % 5 == 0:
  193.             logger.info('Save model...')
  194.             savepath = str(checkpoints_dir) + '/model.pth'
  195.             log_string('Saving at %s' % savepath)
  196.             state = {
  197.                 'epoch': epoch,
  198.                 'model_state_dict': classifier.state_dict(),
  199.                 'optimizer_state_dict': optimizer.state_dict(),
  200.             }
  201.             torch.save(state, savepath)
  202.             log_string('Saving model....')
  203.  
  204.         '''Evaluate on chopped scenes'''
  205.         with torch.no_grad():
  206.             num_batches = len(testDataLoader)
  207.             total_correct = 0
  208.             total_seen = 0
  209.             loss_sum = 0
  210.             labelweights = np.zeros(NUM_CLASSES)
  211.             total_seen_class = [0 for _ in range(NUM_CLASSES)]
  212.             total_correct_class = [0 for _ in range(NUM_CLASSES)]
  213.             total_iou_deno_class = [0 for _ in range(NUM_CLASSES)]
  214.             log_string('---- EPOCH %03d EVALUATION ----' % (global_epoch + 1))
  215.             for i, data in tqdm(enumerate(testDataLoader), total=len(testDataLoader), smoothing=0.9):
  216.                 points, target = data
  217.                 points = points.data.numpy()
  218.                 points = torch.Tensor(points)
  219.                 points, target = points.float().cuda(), target.long().cuda()
  220.                 # device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  221.                 # print("Using device:", device)
  222.                 # classifier = classifier.to(device)
  223.                 # points, target = points.float().to(device), target.long().to(device)
  224.  
  225.                 points = points.transpose(2, 1)
  226.                 classifier = classifier.eval()
  227.                 seg_pred, trans_feat = classifier(points)
  228.                 pred_val = seg_pred.contiguous().cpu().data.numpy()
  229.                 seg_pred = seg_pred.contiguous().view(-1, NUM_CLASSES)
  230.                 batch_label = target.cpu().data.numpy()
  231.                 target = target.view(-1, 1)[:, 0]
  232.                 loss = criterion(seg_pred, target, trans_feat, weights)
  233.                 loss_sum += loss
  234.                 pred_val = np.argmax(pred_val, 2)
  235.                 correct = np.sum((pred_val == batch_label))
  236.                 total_correct += correct
  237.                 total_seen += (BATCH_SIZE * NUM_POINT)
  238.                 tmp, _ = np.histogram(batch_label, range(NUM_CLASSES + 1))
  239.                 labelweights += tmp
  240.                 for l in range(NUM_CLASSES):
  241.                     total_seen_class[l] += np.sum((batch_label == l) )
  242.                     total_correct_class[l] += np.sum((pred_val == l) & (batch_label == l) )
  243.                     total_iou_deno_class[l] += np.sum(((pred_val == l) | (batch_label == l)) )
  244.             labelweights = labelweights.astype(np.float32) / np.sum(labelweights.astype(np.float32))
  245.             mIoU = np.mean(np.array(total_correct_class) / (np.array(total_iou_deno_class, dtype=np.float) + 1e-6))
  246.             log_string('eval mean loss: %f' % (loss_sum / float(num_batches)))
  247.             log_string('eval point avg class IoU: %f' % (mIoU))
  248.             log_string('eval point accuracy: %f' % (total_correct / float(total_seen)))
  249.             log_string('eval point avg class acc: %f' % (
  250.                 np.mean(np.array(total_correct_class) / (np.array(total_seen_class, dtype=np.float) + 1e-6))))
  251.             iou_per_class_str = '------- IoU --------\n'
  252.             for l in range(NUM_CLASSES):
  253.                 iou_per_class_str += 'class %s weight: %.3f, IoU: %.3f \n' % (
  254.                     seg_label_to_cat[l] + ' ' * (14 - len(seg_label_to_cat[l])), labelweights[l - 1],
  255.                     total_correct_class[l] / float(total_iou_deno_class[l]))
  256.  
  257.             log_string(iou_per_class_str)
  258.             log_string('Eval mean loss: %f' % (loss_sum / num_batches))
  259.             log_string('Eval accuracy: %f' % (total_correct / float(total_seen)))
  260.             if mIoU >= best_iou:
  261.                 best_iou = mIoU
  262.                 logger.info('Save model...')
  263.                 savepath = str(checkpoints_dir) + '/best_model.pth'
  264.                 log_string('Saving at %s' % savepath)
  265.                 state = {
  266.                     'epoch': epoch,
  267.                     'class_avg_iou': mIoU,
  268.                     'model_state_dict': classifier.state_dict(),
  269.                     'optimizer_state_dict': optimizer.state_dict(),
  270.                 }
  271.                 torch.save(state, savepath)
  272.                 log_string('Saving model....')
  273.             log_string('Best mIoU: %f' % best_iou)
  274.         global_epoch += 1
  275.  
  276.  
  277. if __name__ == '__main__':
  278.     args = parse_args()
  279.     main(args)
  280.

（4）test_cls.py

  1. from data_utils.ModelNetDataLoader import ModelNetDataLoader
  2. import argparse
  3. import numpy as np
  4. import os
  5. import torch
  6. import logging
  7. from tqdm import tqdm
  8. import sys
  9. import importlib
  10.  
  11. BASE_DIR = os.path.dirname(os.path.abspath(__file__))
  12. ROOT_DIR = BASE_DIR
  13. sys.path.append(os.path.join(ROOT_DIR, 'models'))
  14.  
  15. """
  16. 配置参数：
  17. --normal 
  18. --log_dir pointnet2_cls_msg
  19. """
  20.  
  21. def parse_args():
  22.     '''PARAMETERS'''
  23.     parser = argparse.ArgumentParser('PointNet')
  24.     parser.add_argument('--batch_size', type=int, default=24, help='batch size in training')
  25.     parser.add_argument('--gpu', type=str, default='0', help='specify gpu device')
  26.     parser.add_argument('--num_point', type=int, default=1024, help='Point Number [default: 1024]')
  27.     parser.add_argument('--log_dir', type=str, default='pointnet2_ssg_normal', help='Experiment root')
  28.     parser.add_argument('--normal', action='store_true', default=True, help='Whether to use normal information [default: False]')
  29.     parser.add_argument('--num_votes', type=int, default=3, help='Aggregate classification scores with voting [default: 3]')
  30.     return parser.parse_args()
  31.  
  32. def test(model, loader, num_class=40, vote_num=1):
  33.     mean_correct = []
  34.     class_acc = np.zeros((num_class,3))
  35.     for j, data in tqdm(enumerate(loader), total=len(loader)):
  36.         points, target = data
  37.         target = target[:, 0]
  38.         points = points.transpose(2, 1)
  39.         points, target = points.cuda(), target.cuda()
  40.         classifier = model.eval()
  41.         vote_pool = torch.zeros(target.size()[0],num_class).cuda()
  42.         for _ in range(vote_num):
  43.             pred, _ = classifier(points)
  44.             vote_pool += pred
  45.         pred = vote_pool/vote_num
  46.         pred_choice = pred.data.max(1)[1]
  47.         for cat in np.unique(target.cpu()):
  48.             classacc = pred_choice[target==cat].eq(target[target==cat].long().data).cpu().sum()
  49.             class_acc[cat,0]+= classacc.item()/float(points[target==cat].size()[0])
  50.             class_acc[cat,1]+=1
  51.         correct = pred_choice.eq(target.long().data).cpu().sum()
  52.         mean_correct.append(correct.item()/float(points.size()[0]))
  53.     class_acc[:,2] =  class_acc[:,0]/ class_acc[:,1]
  54.     class_acc = np.mean(class_acc[:,2])
  55.     instance_acc = np.mean(mean_correct)
  56.     return instance_acc, class_acc
  57.  
  58.  
  59. def main(args):
  60.     def log_string(str):
  61.         logger.info(str)
  62.         print(str)
  63.  
  64.     '''HYPER PARAMETER'''
  65.     os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
  66.  
  67.     '''CREATE DIR'''
  68.     experiment_dir = 'log/classification/' + args.log_dir
  69.  
  70.     '''LOG'''
  71.     args = parse_args()
  72.     logger = logging.getLogger("Model")
  73.     logger.setLevel(logging.INFO)
  74.     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  75.     file_handler = logging.FileHandler('%s/eval.txt' % experiment_dir)
  76.     file_handler.setLevel(logging.INFO)
  77.     file_handler.setFormatter(formatter)
  78.     logger.addHandler(file_handler)
  79.     log_string('PARAMETER ...')
  80.     log_string(args)
  81.  
  82.     '''DATA LOADING'''
  83.     log_string('Load dataset ...')
  84.     DATA_PATH = 'data/modelnet40_normal_resampled/'
  85.     TEST_DATASET = ModelNetDataLoader(root=DATA_PATH, npoint=args.num_point, split='test', normal_channel=args.normal)
  86.     testDataLoader = torch.utils.data.DataLoader(TEST_DATASET, batch_size=args.batch_size, shuffle=False, num_workers=4)
  87.  
  88.     '''MODEL LOADING'''
  89.     num_class = 40
  90.     model_name = os.listdir(experiment_dir+'/logs')[0].split('.')[0]
  91.     MODEL = importlib.import_module(model_name)
  92.  
  93.     classifier = MODEL.get_model(num_class,normal_channel=args.normal).cuda()
  94.  
  95.     checkpoint = torch.load(str(experiment_dir) + '/checkpoints/best_model.pth')
  96.     classifier.load_state_dict(checkpoint['model_state_dict'])
  97.  
  98.     with torch.no_grad():
  99.         instance_acc, class_acc = test(classifier.eval(), testDataLoader, vote_num=args.num_votes)
  100.         log_string('Test Instance Accuracy: %f, Class Accuracy: %f' % (instance_acc, class_acc))
  101.  
  102.  
  103.  
  104. if __name__ == '__main__':
  105.     args = parse_args()
  106.     main(args)

（5）test_partseg.py

  1. """
  2. Author: Benny
  3. Date: Nov 2019
  4. """
  5. import argparse
  6. import os
  7. from data_utils.ShapeNetDataLoader import PartNormalDataset
  8. import torch
  9. import logging
  10. import sys
  11. import importlib
  12. from tqdm import tqdm
  13. import numpy as np
  14.  
  15. BASE_DIR = os.path.dirname(os.path.abspath(__file__))
  16. ROOT_DIR = BASE_DIR
  17. sys.path.append(os.path.join(ROOT_DIR, 'models'))
  18.  
  19. seg_classes = {'Earphone': [16, 17, 18], 'Motorbike': [30, 31, 32, 33, 34, 35], 'Rocket': [41, 42, 43], 'Car': [8, 9, 10, 11], 'Laptop': [28, 29], 'Cap': [6, 7], 'Skateboard': [44, 45, 46], 'Mug': [36, 37], 'Guitar': [19, 20, 21], 'Bag': [4, 5], 'Lamp': [24, 25, 26, 27], 'Table': [47, 48, 49], 'Airplane': [0, 1, 2, 3], 'Pistol': [38, 39, 40], 'Chair': [12, 13, 14, 15], 'Knife': [22, 23]}
  20. seg_label_to_cat = {} # {0:Airplane, 1:Airplane, ...49:Table}
  21. for cat in seg_classes.keys():
  22.     for label in seg_classes[cat]:
  23.         seg_label_to_cat[label] = cat
  24.  
  25. def to_categorical(y, num_classes):
  26.     """ 1-hot encodes a tensor """
  27.     new_y = torch.eye(num_classes)[y.cpu().data.numpy(),]
  28.     if (y.is_cuda):
  29.         return new_y.cuda()
  30.     return new_y
  31.  
  32.  
  33. def parse_args():
  34.     '''PARAMETERS'''
  35.     parser = argparse.ArgumentParser('PointNet')
  36.     parser.add_argument('--batch_size', type=int, default=24, help='batch size in testing [default: 24]')
  37.     parser.add_argument('--gpu', type=str, default='0', help='specify gpu device [default: 0]')
  38.     # parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
  39.     parser.add_argument('--num_point', type=int, default=2048, help='Point Number [default: 2048]')
  40.     parser.add_argument('--log_dir', type=str, default='pointnet2_part_seg_ssg', help='Experiment root')
  41.     # parser.add_argument('--log_dir', type=str, default='visual', help='Experiment root')
  42.     parser.add_argument('--normal', action='store_true', default=False, help='Whether to use normal information [default: False]')
  43.     parser.add_argument('--num_votes', type=int, default=3, help='Aggregate segmentation scores with voting [default: 3]')
  44.     return parser.parse_args()
  45.  
  46. def main(args):
  47.     def log_string(str):
  48.         logger.info(str)
  49.         print(str)
  50.  
  51.     '''HYPER PARAMETER'''
  52.     os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
  53.     experiment_dir = 'log/part_seg/' + args.log_dir
  54.  
  55.     '''LOG'''
  56.     args = parse_args()
  57.     logger = logging.getLogger("Model")
  58.     logger.setLevel(logging.INFO)
  59.     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  60.     file_handler = logging.FileHandler('%s/eval.txt' % experiment_dir)
  61.     file_handler.setLevel(logging.INFO)
  62.     file_handler.setFormatter(formatter)
  63.     logger.addHandler(file_handler)
  64.     log_string('PARAMETER ...')
  65.     log_string(args)
  66.  
  67.     root = 'data/shapenetcore_partanno_segmentation_benchmark_v0_normal/'
  68.  
  69.     TEST_DATASET = PartNormalDataset(root = root, npoints=args.num_point, split='test', normal_channel=args.normal)
  70.     testDataLoader = torch.utils.data.DataLoader(TEST_DATASET, batch_size=args.batch_size,shuffle=False, num_workers=4)
  71.     log_string("The number of test data is: %d" %  len(TEST_DATASET))
  72.     num_classes = 16
  73.     num_part = 50
  74.  
  75.     '''MODEL LOADING'''
  76.     model_name = os.listdir(experiment_dir+'/logs')[0].split('.')[0]
  77.     MODEL = importlib.import_module(model_name)
  78.     classifier = MODEL.get_model(num_part, normal_channel=args.normal).cuda()
  79.     checkpoint = torch.load(str(experiment_dir) + '/checkpoints/best_model.pth')
  80.     classifier.load_state_dict(checkpoint['model_state_dict'])
  81.  
  82.  
  83.     with torch.no_grad():
  84.         test_metrics = {}
  85.         total_correct = 0
  86.         total_seen = 0
  87.         total_seen_class = [0 for _ in range(num_part)]
  88.         total_correct_class = [0 for _ in range(num_part)]
  89.         shape_ious = {cat: [] for cat in seg_classes.keys()}
  90.         seg_label_to_cat = {}  # {0:Airplane, 1:Airplane, ...49:Table}
  91.         for cat in seg_classes.keys():
  92.             for label in seg_classes[cat]:
  93.                 seg_label_to_cat[label] = cat
  94.  
  95.         for batch_id, (points, label, target) in tqdm(enumerate(testDataLoader), total=len(testDataLoader), smoothing=0.9):
  96.             batchsize, num_point, _ = points.size()
  97.             cur_batch_size, NUM_POINT, _ = points.size()
  98.             points, label, target = points.float().cuda(), label.long().cuda(), target.long().cuda()
  99.             points = points.transpose(2, 1)
  100.             classifier = classifier.eval()
  101.             vote_pool = torch.zeros(target.size()[0], target.size()[1], num_part).cuda()
  102.             for _ in range(args.num_votes):
  103.                 seg_pred, _ = classifier(points, to_categorical(label, num_classes))
  104.                 vote_pool += seg_pred
  105.             seg_pred = vote_pool / args.num_votes
  106.             cur_pred_val = seg_pred.cpu().data.numpy()
  107.             cur_pred_val_logits = cur_pred_val
  108.             cur_pred_val = np.zeros((cur_batch_size, NUM_POINT)).astype(np.int32)
  109.             target = target.cpu().data.numpy()
  110.             for i in range(cur_batch_size):
  111.                 cat = seg_label_to_cat[target[i, 0]]
  112.                 logits = cur_pred_val_logits[i, :, :]
  113.                 cur_pred_val[i, :] = np.argmax(logits[:, seg_classes[cat]], 1) + seg_classes[cat][0]
  114.             correct = np.sum(cur_pred_val == target)
  115.             total_correct += correct
  116.             total_seen += (cur_batch_size * NUM_POINT)
  117.  
  118.             for l in range(num_part):
  119.                 total_seen_class[l] += np.sum(target == l)
  120.                 total_correct_class[l] += (np.sum((cur_pred_val == l) & (target == l)))
  121.  
  122.             for i in range(cur_batch_size):
  123.                 segp = cur_pred_val[i, :]
  124.                 segl = target[i, :]
  125.                 cat = seg_label_to_cat[segl[0]]
  126.                 part_ious = [0.0 for _ in range(len(seg_classes[cat]))]
  127.                 for l in seg_classes[cat]:
  128.                     if (np.sum(segl == l) == 0) and (
  129.                             np.sum(segp == l) == 0):  # part is not present, no prediction as well
  130.                         part_ious[l - seg_classes[cat][0]] = 1.0
  131.                     else:
  132.                         part_ious[l - seg_classes[cat][0]] = np.sum((segl == l) & (segp == l)) / float(
  133.                             np.sum((segl == l) | (segp == l)))
  134.                 shape_ious[cat].append(np.mean(part_ious))
  135.  
  136.         all_shape_ious = []
  137.         for cat in shape_ious.keys():
  138.             for iou in shape_ious[cat]:
  139.                 all_shape_ious.append(iou)
  140.             shape_ious[cat] = np.mean(shape_ious[cat])
  141.         mean_shape_ious = np.mean(list(shape_ious.values()))
  142.         test_metrics['accuracy'] = total_correct / float(total_seen)
  143.         test_metrics['class_avg_accuracy'] = np.mean(
  144.             np.array(total_correct_class) / np.array(total_seen_class, dtype=np.float))
  145.         for cat in sorted(shape_ious.keys()):
  146.             log_string('eval mIoU of %s %f' % (cat + ' ' * (14 - len(cat)), shape_ious[cat]))
  147.         test_metrics['class_avg_iou'] = mean_shape_ious
  148.         test_metrics['inctance_avg_iou'] = np.mean(all_shape_ious)
  149.  
  150.  
  151.     log_string('Accuracy is: %.5f'%test_metrics['accuracy'])
  152.     log_string('Class avg accuracy is: %.5f'%test_metrics['class_avg_accuracy'])
  153.     log_string('Class avg mIOU is: %.5f'%test_metrics['class_avg_iou'])
  154.     log_string('Inctance avg mIOU is: %.5f'%test_metrics['inctance_avg_iou'])
  155.  
  156. if __name__ == '__main__':
  157.     args = parse_args()
  158.     main(args)
  159.

（6）test_semseg.py

  1. """
  2. Author: Benny
  3. Date: Nov 2019
  4. """
  5. import argparse
  6. import os
  7. from data_utils.S3DISDataLoader import ScannetDatasetWholeScene
  8. from data_utils.indoor3d_util import g_label2color
  9. import torch
  10. import logging
  11. from pathlib import Path
  12. import sys
  13. import importlib
  14. from tqdm import tqdm
  15. import provider
  16. import numpy as np
  17.  
  18. BASE_DIR = os.path.dirname(os.path.abspath(__file__))
  19. ROOT_DIR = BASE_DIR
  20. sys.path.append(os.path.join(ROOT_DIR, 'models'))
  21.  
  22. classes = ['ceiling','floor','wall','beam','column','window','door','table','chair','sofa','bookcase','board','clutter']
  23. class2label = {cls: i for i,cls in enumerate(classes)}
  24. seg_classes = class2label
  25. seg_label_to_cat = {}
  26. for i,cat in enumerate(seg_classes.keys()):
  27.     seg_label_to_cat[i] = cat
  28.  
  29. def parse_args():
  30.     '''PARAMETERS'''
  31.     parser = argparse.ArgumentParser('Model')
  32.     parser.add_argument('--batch_size', type=int, default=32, help='batch size in testing [default: 32]')
  33.     parser.add_argument('--gpu', type=str, default='0', help='specify gpu device')
  34.     parser.add_argument('--num_point', type=int, default=4096, help='Point Number [default: 4096]')
  35.     parser.add_argument('--log_dir', type=str, default='pointnet2_sem_seg', help='Experiment root')
  36.     parser.add_argument('--visual', action='store_true', default=True, help='Whether visualize result [default: False]')
  37.     parser.add_argument('--test_area', type=int, default=5, help='Which area to use for test, option: 1-6 [default: 5]')
  38.     parser.add_argument('--num_votes', type=int, default=5, help='Aggregate segmentation scores with voting [default: 5]')
  39.     return parser.parse_args()
  40.  
  41. def add_vote(vote_label_pool, point_idx, pred_label, weight):
  42.     B = pred_label.shape[0]
  43.     N = pred_label.shape[1]
  44.     for b in range(B):
  45.         for n in range(N):
  46.             if weight[b,n]:
  47.                 vote_label_pool[int(point_idx[b, n]), int(pred_label[b, n])] += 1
  48.     return vote_label_pool
  49.  
  50. def main(args):
  51.     def log_string(str):
  52.         logger.info(str)
  53.         print(str)
  54.  
  55.     '''HYPER PARAMETER'''
  56.     os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
  57.     experiment_dir = 'log/sem_seg/' + args.log_dir
  58.     visual_dir = experiment_dir + '/visual/'
  59.     visual_dir = Path(visual_dir)
  60.     visual_dir.mkdir(exist_ok=True)
  61.  
  62.     '''LOG'''
  63.     args = parse_args()
  64.     logger = logging.getLogger("Model")
  65.     logger.setLevel(logging.INFO)
  66.     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  67.     file_handler = logging.FileHandler('%s/eval.txt' % experiment_dir)
  68.     file_handler.setLevel(logging.INFO)
  69.     file_handler.setFormatter(formatter)
  70.     logger.addHandler(file_handler)
  71.     log_string('PARAMETER ...')
  72.     log_string(args)
  73.  
  74.     NUM_CLASSES = 13
  75.     BATCH_SIZE = args.batch_size
  76.     NUM_POINT = args.num_point
  77.  
  78.     root = 'data/stanford_indoor3d/'
  79.  
  80.     TEST_DATASET_WHOLE_SCENE = ScannetDatasetWholeScene(root, split='test', test_area=args.test_area, block_points=NUM_POINT)
  81.     log_string("The number of test data is: %d" %  len(TEST_DATASET_WHOLE_SCENE))
  82.  
  83.     '''MODEL LOADING'''
  84.     model_name = os.listdir(experiment_dir+'/logs')[0].split('.')[0]
  85.     MODEL = importlib.import_module(model_name)
  86.     classifier = MODEL.get_model(NUM_CLASSES).cuda()
  87.     checkpoint = torch.load(str(experiment_dir) + '/checkpoints/best_model.pth')
  88.     classifier.load_state_dict(checkpoint['model_state_dict'])
  89.  
  90.     with torch.no_grad():
  91.         scene_id = TEST_DATASET_WHOLE_SCENE.file_list
  92.         scene_id = [x[:-4] for x in scene_id]
  93.         num_batches = len(TEST_DATASET_WHOLE_SCENE)
  94.  
  95.         total_seen_class = [0 for _ in range(NUM_CLASSES)]
  96.         total_correct_class = [0 for _ in range(NUM_CLASSES)]
  97.         total_iou_deno_class = [0 for _ in range(NUM_CLASSES)]
  98.  
  99.         log_string('---- EVALUATION WHOLE SCENE----')
  100.  
  101.         for batch_idx in range(num_batches):
  102.             print("visualize [%d/%d] %s ..." % (batch_idx+1, num_batches, scene_id[batch_idx]))
  103.             total_seen_class_tmp = [0 for _ in range(NUM_CLASSES)]
  104.             total_correct_class_tmp = [0 for _ in range(NUM_CLASSES)]
  105.             total_iou_deno_class_tmp = [0 for _ in range(NUM_CLASSES)]
  106.             if args.visual:
  107.                 fout = open(os.path.join(visual_dir, scene_id[batch_idx] + '_pred.obj'), 'w')
  108.                 fout_gt = open(os.path.join(visual_dir, scene_id[batch_idx] + '_gt.obj'), 'w')
  109.  
  110.             whole_scene_data = TEST_DATASET_WHOLE_SCENE.scene_points_list[batch_idx]
  111.             whole_scene_label = TEST_DATASET_WHOLE_SCENE.semantic_labels_list[batch_idx]
  112.             vote_label_pool = np.zeros((whole_scene_label.shape[0], NUM_CLASSES))
  113.             for _ in tqdm(range(args.num_votes), total=args.num_votes):
  114.                 scene_data, scene_label, scene_smpw, scene_point_index = TEST_DATASET_WHOLE_SCENE[batch_idx]
  115.                 num_blocks = scene_data.shape[0]
  116.                 s_batch_num = (num_blocks + BATCH_SIZE - 1) // BATCH_SIZE
  117.                 batch_data = np.zeros((BATCH_SIZE, NUM_POINT, 9))
  118.  
  119.                 batch_label = np.zeros((BATCH_SIZE, NUM_POINT))
  120.                 batch_point_index = np.zeros((BATCH_SIZE, NUM_POINT))
  121.                 batch_smpw = np.zeros((BATCH_SIZE, NUM_POINT))
  122.                 for sbatch in range(s_batch_num):
  123.                     start_idx = sbatch * BATCH_SIZE
  124.                     end_idx = min((sbatch + 1) * BATCH_SIZE, num_blocks)
  125.                     real_batch_size = end_idx - start_idx
  126.                     batch_data[0:real_batch_size, ...] = scene_data[start_idx:end_idx, ...]
  127.                     batch_label[0:real_batch_size, ...] = scene_label[start_idx:end_idx, ...]
  128.                     batch_point_index[0:real_batch_size, ...] = scene_point_index[start_idx:end_idx, ...]
  129.                     batch_smpw[0:real_batch_size, ...] = scene_smpw[start_idx:end_idx, ...]
  130.                     batch_data[:, :, 3:6] /= 1.0
  131.  
  132.                     torch_data = torch.Tensor(batch_data)
  133.                     torch_data= torch_data.float().cuda()
  134.                     torch_data = torch_data.transpose(2, 1)
  135.                     seg_pred, _ = classifier(torch_data)
  136.                     batch_pred_label = seg_pred.contiguous().cpu().data.max(2)[1].numpy()
  137.  
  138.                     vote_label_pool = add_vote(vote_label_pool, batch_point_index[0:real_batch_size, ...],
  139.                                                batch_pred_label[0:real_batch_size, ...],
  140.                                                batch_smpw[0:real_batch_size, ...])
  141.  
  142.             pred_label = np.argmax(vote_label_pool, 1)
  143.  
  144.             for l in range(NUM_CLASSES):
  145.                 total_seen_class_tmp[l] += np.sum((whole_scene_label == l))
  146.                 total_correct_class_tmp[l] += np.sum((pred_label == l) & (whole_scene_label == l))
  147.                 total_iou_deno_class_tmp[l] += np.sum(((pred_label == l) | (whole_scene_label == l)))
  148.                 total_seen_class[l] += total_seen_class_tmp[l]
  149.                 total_correct_class[l] += total_correct_class_tmp[l]
  150.                 total_iou_deno_class[l] += total_iou_deno_class_tmp[l]
  151.  
  152.             iou_map = np.array(total_correct_class_tmp) / (np.array(total_iou_deno_class_tmp, dtype=np.float64) + 1e-6)
  153.             print(iou_map)
  154.             arr = np.array(total_seen_class_tmp)
  155.             tmp_iou = np.mean(iou_map[arr != 0])
  156.             log_string('Mean IoU of %s: %.4f' % (scene_id[batch_idx], tmp_iou))
  157.             print('----------------------------')
  158.  
  159.             filename = os.path.join(visual_dir, scene_id[batch_idx] + '.txt')
  160.             with open(filename, 'w') as pl_save:
  161.                 for i in pred_label:
  162.                     pl_save.write(str(int(i)) + '\n')
  163.                 pl_save.close()
  164.             for i in range(whole_scene_label.shape[0]):
  165.                 color = g_label2color[pred_label[i]]
  166.                 color_gt = g_label2color[whole_scene_label[i]]
  167.                 if args.visual:
  168.                     fout.write('v %f %f %f %d %d %d\n' % (
  169.                     whole_scene_data[i, 0], whole_scene_data[i, 1], whole_scene_data[i, 2], color[0], color[1],
  170.                     color[2]))
  171.                     fout_gt.write(
  172.                         'v %f %f %f %d %d %d\n' % (
  173.                         whole_scene_data[i, 0], whole_scene_data[i, 1], whole_scene_data[i, 2], color_gt[0],
  174.                         color_gt[1], color_gt[2]))
  175.             if args.visual:
  176.                 fout.close()
  177.                 fout_gt.close()
  178.  
  179.         IoU = np.array(total_correct_class) / (np.array(total_iou_deno_class, dtype=np.float) + 1e-6)
  180.         iou_per_class_str = '------- IoU --------\n'
  181.         for l in range(NUM_CLASSES):
  182.             iou_per_class_str += 'class %s, IoU: %.3f \n' % (
  183.                 seg_label_to_cat[l] + ' ' * (14 - len(seg_label_to_cat[l])),
  184.                 total_correct_class[l] / float(total_iou_deno_class[l]))
  185.         log_string(iou_per_class_str)
  186.         log_string('eval point avg class IoU: %f' % np.mean(IoU))
  187.         log_string('eval whole scene point avg class acc: %f' % (
  188.             np.mean(np.array(total_correct_class) / (np.array(total_seen_class, dtype=np.float) + 1e-6))))
  189.         log_string('eval whole scene point accuracy: %f' % (
  190.                     np.sum(total_correct_class) / float(np.sum(total_seen_class) + 1e-6)))
  191.  
  192.         print("Done!")
  193.  
  194. if __name__ == '__main__':
  195.     args = parse_args()
  196.     main(args)

上面这些都是调整好的代码应该是可以直接跑通的，如果哪个程序有问题可以粘贴我的程序过去试一试，注意一些文件路径要修改成自己的。

三、复现过程中遇到的问题总结

（1）首先把下面这些文件夹依次打开，你会发现导入的包被标红，因为路径不对

将下面

from pointnet import PointNetEncoder, feature_transform_reguliarzer

修改为

from models.pointnet import PointNetEncoder, feature_transform_reguliarzer

models.是包含pointnet.py的文件夹，也就是说要精确到文件所在文件夹，系统才能正确找到，不报错，其他的脚本遇到这种情况类似处理

（2）报错：AttributeError: module ‘numpy‘ has no attribute ‘float‘

出现这个问题的原因是：从numpy1.24起删除了numpy.bool、numpy.int、numpy.float、numpy.complex、numpy.object、numpy.str、numpy.long、numpy.unicode类型的支持。解决上诉问题主要有两种方法：

方法一：修改numpy版本

安装numpy1.24之前的版本

  1. pip uninstall numpy
  2. pip install numpy==1.23.5

方法二：修改代码

可以用python内置类型或者np.ndarray类型替换：np.float替换为float或者np.float64/np.float32

参考链接：AttributeError: module ‘numpy‘ has no attribute ‘float‘

（3）报错：

choice = np.random.choice(len(point_set.shape[0]), npoints, replace=True) TypeError: object of type 'int' has no len()

将

 choice = np.random.choice(len(point_set.shape[0]), npoints, replace=True)

替换为

choice = np.random.choice(point_set.shape[0], npoints, replace=True)

（4）报错：

return F.conv1d(input, weight, bias, self.stride, RuntimeError: Given groups=1, weight of size [64, 6, 1], expected input[16, 9, 4096] to have 6 channels, but got 9 channels instead

上面是复现时运行train_semseg.py报错RuntimeError:

  • 该个错误主要是因为S3DIS数据集的数据具有9个通道，涉及xyz、rgb和归一化XYZ。但是代码仅支持 3 或 6 个通道。要解决此问题，应进行一些小的修改。

1 pointnet_sem_seg.py;通过添加 if来考虑通道 =9 的情况。with_normalized_xyz params

  1. class get_model(nn.Module):
  2.     def __init__(self, num_class, with_rgb=True, with_normalized_xyz=True):
  3.         super(get_model, self).__init__()
  4.         if with_rgb:
  5.             channel = 6
  6.             if with_normalized_xyz:
  7.                 channel= 9
  8.         else:
  9.             ...

2 pointnet.py;更改 PointNetEncoder 的前向方法，稍微修改拆分方法

  1.     def forward(self, x):
  2.         B, D, N = x.size() # batchsize，3（xyz坐标）或6（xyz坐标+法向量），1024(一个物体所取的点的数目）
  3.         trans = self.stn(x) # STN3d T-Net
  4.         x = x.transpose(2, 1) # 交换一个tensor的两个维度
  5.         if D >3 :
  6.             # x, feature = x.split(3,dim=2)
  7.             x, feature = x.split([3,D-3],dim=2)

3 这样就可以解决S3DIS数据集在pointnet++训练时的场景分割报错了。

参考自：pointnet++复现时运行train_semseg.py报错RuntimeError:

（5）报错

return open(self.baseFilename, self.mode, encoding=self.encoding)

PermissionError: [Errno 13] Permission denied: 'D:\\cs\\Pointnet2\\log\\part_seg\\pointnet2_part_seg_ssg\\eval.txt'

或

model_name = os.listdir(experiment_dir+'/logs')[0].split('.')[0]

IndexError: list index out of range

这是因为该路径下没有这个名称的文件夹或者文件夹名称不对，我一开始就是文件夹名字写错了，应该是ssg我写成了msg所以一直报错

要有这个文件夹

文件夹里要有这些文件

如果没有的话可以从以往的2024-01-06_22-21记录中复制过来，实在不行建立内容为空的文件，但是一定要让系统在搜索路径的时候能找到

（6）FileNotFoundError: [WinError 3] 系统找不到指定的路径的解决方法

判断文件的父子目录设置是否正确

可参考：FileNotFoundError: [WinError 3] 系统找不到指定的路径。的解决方法

（7）self = reduction.pickle.load(from_parent) EOFError: Ran out of input的解决方法

这是在运行train_semseg.py程序时遇到的错误

将num_workers改为0即可

修改前

修改后

参考：self = reduction.pickle.load(from_parent) EOFError: Ran out of input的解决方法

（8）报错

    rooms = sorted(os.listdir(data_root))
FileNotFoundError: [WinError 3] 系统找不到指定的路径。: 'data/stanford_indoor3d/'

这是因为我们的data文件夹里还没有stanford_indoor3d这个文件夹，这是个数据集，需要我们先运行个脚本生成

下载 3D indoor parsing dataset ( S3DIS ) 数据集 Stanford3dDataset_v1.2_Aligned_Version.zip 并解压 到 data/s3dis/Stanford3dDataset_v1.2_Aligned_Version/ ，首先需要进行的是预处理工作：
 

  1. cd data_utils
  2. python collect_indoor3d_data.py

或者在Pycharm中运行

报错原因是我们没有建立s3dis文件夹，并将Stanford3dDataset_v1.2_Aligned_Version放入其中所以脚本运行时找不到路径，文件夹像下面这样处理

然后再运行collect_indoor3d_data.py就成功了，如下图所示

此时我们在回到 data/s3dis/Stanford3dDataset_v1.2_Aligned_Version/文件夹会发现多了好多npy文件

而我们的stanford_indoor3d文件夹里是空的，但是后续模型数据集的加载又是来自这个文件夹，因此将所有的npy文件复制到stanford_indoor3d文件夹中

现在此时data文件夹里的目录结构是下面这样的

再回来运行train_semseg.py程序就可以了，可能会遇到上面提到的（4）和（7）的报错，对应上面方法就可以解决，成功截图如下：

先训练，训练完才能用test_semseg.py进行测试，测试结果是可以进行可视化的，只需要把test_semseg.py中，visual的default的参数值改为True就可以生成obj文件，然后可以用CloudCompare软件进行可视化

注意，我们网盘下载下来的文件里没有visual，我们要自己建立，否则会因找不到文件路径而报错，目录结构如下，如果缺少eval.txt或其他文件夹，仿着classification建好

运行其他的也是，如果找不到路径就缺啥见啥或检查路径和文件名对不对

参考自：Pointnet++环境配置+复现

（9）visualizer文件中有个show3d_balls.py文件，适用于可视化的，官方链接里的README有提到，但是用到的一些so文件，是ubuntu里的命令文件，如果想在windows下能运行，需要重新改写。

1、win10系统下build.sh文件运行问题

安装git–>安装g++

安装git：https://so.csdn.net/so/search?q=%E5%AE%89%E8%A3%85git&t=&u=

安装g++： MinGW下载和安装教程

可通过linux系统或者已安装的git中bash环境运行build.sh脚本
安装完毕g++之后可通过sh build.sh运行，见上图

2、win10系统下download_data.sh文件运行问题

该文件位于链接https://github.com/KuangenZhang/ldgcnn的part_seg的文件夹下

对于sh download_data运行问题的错误，主要原因为Issued certificate has expired，win10系统下解决方案为：通过记事本打开sh文件，wget指令后添加–no-check-certificate
若显示无–no-check-certificate参数，参考https://blog.csdn.net/topsogn/article/details/121217646?spm=1001.2014.3001.5501

  1. def download():
  2.     BASE_DIR = os.path.dirname(os.path.abspath(__file__))
  3.     DATA_DIR = os.path.join(BASE_DIR, 'data')
  4.     if not os.path.exists(DATA_DIR):
  5.         os.mkdir(DATA_DIR)
  6.     if not os.path.exists(os.path.join(DATA_DIR, 'modelnet40_ply_hdf5_2048')):
  7.         www = 'https://shapenet.cs.stanford.edu/media/modelnet40_ply_hdf5_2048.zip'
  8.         zipfile = os.path.basename(www)
  9.         os.system('wget --no-check-certificate %s' % (www))
  10.         os.system('unzip %s' % (zipfile))
  11.         os.system('mv %s %s' % (zipfile[:-4], DATA_DIR))
  12.         os.system('rm %s' % (zipfile))

若显示unzip不是内部或外部命令，也不是可运行的程序或批处理文件。则可通过在系统环境变量中添加windows下的zip.exe和unzip.exe的路径

3、 raise OSError(“no file with expected extension”)问题
在运行PointNet的可视化程序时，作者只提供了linux平台下的动态链接库程序源码,自己的windows平台下无法调用。发现是动态链接库的文件格式不对，遂学习如何将.so文件转换成.dll文件
3.1 安装viusal studio

3.2 新建C++动态链接库项目

3.3 修改头文件pch.h
  1. #ifndef PCH_H
  2. #define PCH_H
  3.  
  4. // 添加要在此处预编译的标头
  5. #include "framework.h"
  6.  
  7. #endif //PCH_H
  8. //定义宏
  9. #ifdef IMPORT_DLL
  10. #else
  11. #define IMPORT_DLL extern "C" _declspec(dllimport) //指的是允许将其给外部调用
  12. #endif
  13.  
  14. // 改为你所需要的链接库函数
  15. IMPORT_DLL void render_ball(int h, int w, unsigned char* show, int n, int* xyzs, float* c0, float* c1, float* c2, int r);

3.4 重写dllmain.cpp文件
  1. // dllmain.cpp : 定义 DLL 应用程序的入口点。
  2. #include "pch.h"
  3. #include <cstdio>
  4. #include <vector>
  5. #include <algorithm>
  6. #include <math.h>
  7. using namespace std;
  8.  
  9. struct PointInfo {
  10. 	int x, y, z;
  11. 	float r, g, b;
  12. };
  13. void render_ball(int h, int w, unsigned char* show, int n, int* xyzs, float* c0, float* c1, float* c2, int r) {
  14. 	r = max(r, 1);
  15. 	vector<int> depth(h * w, -2100000000);
  16. 	vector<PointInfo> pattern;
  17. 	for (int dx = -r; dx <= r; dx++)
  18. 		for (int dy = -r; dy <= r; dy++)
  19. 			if (dx * dx + dy * dy < r * r) {
  20. 				double dz = sqrt(double(r * r - dx * dx - dy * dy));
  21. 				PointInfo pinfo;
  22. 				pinfo.x = dx;
  23. 				pinfo.y = dy;
  24. 				pinfo.z = dz;
  25. 				pinfo.r = dz / r;
  26. 				pinfo.g = dz / r;
  27. 				pinfo.b = dz / r;
  28. 				pattern.push_back(pinfo);
  29. 			}
  30. 	double zmin = 0, zmax = 0;
  31. 	for (int i = 0; i < n; i++) {
  32. 		if (i == 0) {
  33. 			zmin = xyzs[i * 3 + 2] - r;
  34. 			zmax = xyzs[i * 3 + 2] + r;
  35. 		}
  36. 		else {
  37. 			zmin = min(zmin, double(xyzs[i * 3 + 2] - r));
  38. 			zmax = max(zmax, double(xyzs[i * 3 + 2] + r));
  39. 		}
  40. 	}
  41. 	for (int i = 0; i < n; i++) {
  42. 		int x = xyzs[i * 3 + 0], y = xyzs[i * 3 + 1], z = xyzs[i * 3 + 2];
  43. 		for (int j = 0; j<int(pattern.size()); j++) {
  44. 			int x2 = x + pattern[j].x;
  45. 			int y2 = y + pattern[j].y;
  46. 			int z2 = z + pattern[j].z;
  47. 			if (!(x2 < 0 || x2 >= h || y2 < 0 || y2 >= w) && depth[x2 * w + y2] < z2) {
  48. 				depth[x2 * w + y2] = z2;
  49. 				double intensity = min(1.0, (z2 - zmin) / (zmax - zmin) * 0.7 + 0.3);
  50. 				show[(x2 * w + y2) * 3 + 0] = pattern[j].b * c2[i] * intensity;
  51. 				show[(x2 * w + y2) * 3 + 1] = pattern[j].g * c0[i] * intensity;
  52. 				show[(x2 * w + y2) * 3 + 2] = pattern[j].r * c1[i] * intensity;
  53. 			}
  54. 		}
  55. 	}
  56. }
  57. // 具体内容改为你的文件内容
  58.

转载链接：https://blog.csdn.net/Moringstarluc/article/details/105702543

注： 若pycharm调试时出现OSError: [WinError 193] %1 不是有效的 Win32 应用程序 的问题

​

原因为visual调试时的 配置: Debug Win32，需修改为Win64，解决方案见下图，修改为x64即可

​

（10）报错

FileNotFoundError: [Errno 2] No such file or directory: 'E:\\临时

\\Pointnet2\\log\\part_seg\\pointnet2_part_seg_ssg\\eval.txt'

这个就是运行test_partseg.py报的错，原因是原文件家里有一个pointnet2_part_seg_msg的文件夹而我们这里找的是pointnet2_part_seg_ssg文件夹，因此我们要自己建立，结构如下

然后再运行就可以了

（11）报错

FileNotFoundError: [WinError 3] 系统找不到指定的路径。: 'log\\sem_seg\\pointnet2_sem_seg\\visual'

这是运行test_semseg,py找不到文件，做法类似于上面建立文件夹，后续如何用test_semseg,py前面已经介绍

（12）最先开始遇到的错误是，运行train_cls.py遇到的报错

（1）
    return forward_call(*input, **kwargs)
TypeError: forward() missing 1 required positional argument: 'cls_label'
 

​

一开始查这个问题，一直没有解决掉，后面按照（4）进行修改后，报错变成下面这样了

    print(points.shape) #第三次：[8,128,640],640个特征
AttributeError: 'NoneType' object has no attribute 'shape'

问题在pointnet_util.py这里

将

  1.         if points is not None:
  2.             points = points.permute(0, 2, 1)
  3.         print(points.shape) #第三次：[8,128,640],640个特征

改为

  1.             if points is not None:
  2.                 points = points.permute(0, 2, 1)
  3.                 print(points.shape) #第三次：[8,128,640],640个特征

即把print朝里面缩进一下，然后就可以正常跑了

至此，所有程序就都可以正常跑了，复现完成！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/519244
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号