1、生成指定格式的label文件
注意在写的过程中完成label_map_invs，
注意在写的过程中完成label_map_invs，
注意在写的过程中完成label_map_invs，
参考：
https://github.com/PRBonn/semantic-kitti-api/blob/master/remap_semantic_labels.py
使用脚本运行
run.sh
#!/bin/bash
for i in $(seq 11 21)
do
echo "===> start sequence ${i}.";
/home/xiaokeai1/anaconda3/envs/torch1.7/bin/python \
SemanticKITTI_eval.py --device 0 --sequence $i --outDIR submission
echo "===> finish sequence ${i}.";
done
eval.py
'''
Description: 评估kitti测试集, 生成对应的.label文件
Author: suyunzheng
Date: 2022-04-13 10:53:16
LastEditTime: 2022-04-14 08:53:06
LastEditors: maple
'''
import os
import sys
from turtle import pen, shapesize
import numpy as np
from sklearn import preprocessing
from sklearn.metrics import DetCurveDisplay
from tqdm import tqdm
import torch
from yaml import parse
from core import builder
import argparse
import open3d as o3d
import time
from multiprocessing.dummy import Pool as ThreadPool
import logging
from core.models import semantic_kitti
logging.basicConfig(format='%(asctime)s.%(msecs)03d [%(levelname)s] [%(filename)s, line:%(lineno)d] %(message)s',
datefmt='## %Y-%m-%d %H:%M:%S')
logging.getLogger().setLevel(logging.INFO)
logger = logging.getLogger()
from visualize_model_pred import process_point_cloud
global device
# if torch.cuda.is_available():
# device = 'cuda:0'
# else:
# device = 'cpu'
class kittiEval:
'''
description: 输入root_path会在上一级目录下创建对应的文件夹
param {*}
return {*}
param {*} self
param {*} root_path
'''
def __init__(self, root_path, configs) -> None:
self.feed_dict = None
self.configs = configs
# logger.info("===> Load configs")
# self.root_path:/mnt/software/suyunzheng/data/semantic-kitti/unzip_kitti_dataset
self.root_path = root_path
tmp_list = self.root_path.split("/")[:-1]
# /mnt/software/suyunzheng/data/semantic-kitti
self.output_path = '/'
for head in tmp_list:
self.output_path = os.path.join(self.output_path, head )
# self.output_path:/mnt/software/suyunzheng/data/semantic-kitti/test_output
self.output_path = os.path.join(self.output_path, configs.outDIR, 'sequences')
logger.info("===> label file will be saved at:{}".format(self.output_path))
try:
os.makedirs(self.output_path, exist_ok=False)
except OSError:
logger.error('===> {} already exists'.format(self.output_path))
pass
else:
logger.info("===> mkdirs {}".format(self.output_path))
pass
# 读取一个文件，生成一个.label文件
'''
description:
param {*}
return {*}
param {*} self
param {*} sequence, int
'''
def get_pred(self, sequence):
sequence_str = str(sequence)
velodyne_dir = os.path.join(self.root_path, sequence_str,'velodyne')
input_point_clouds = sorted(os.listdir(velodyne_dir))
# self.output_path:/mnt/software/suyunzheng/data/semantic-kitti/test_output/sequences/11
label_dir = os.path.join(self.output_path, sequence_str)
# self.output_path:/mnt/software/suyunzheng/data
# /semantic-kitti/test_output/sequences/11/predictions
predictions_dir = os.path.join(label_dir, 'predictions')
try:
os.makedirs(predictions_dir, exist_ok=False)
except OSError:
logger.error('===> {} already exists'.format(predictions_dir))
pass
else:
logger.info("===> mkdirs {}".format(predictions_dir))
# 用作线程池
def process(point_cloud_name):
logger.info("===> point_cloud_name:{}".format(point_cloud_name))
point_cloud_name_prue = point_cloud_name.split(".")[-2] # 000000
label_name = f'{point_cloud_name_prue}.label' # 000000.label
pc = np.fromfile(f'{velodyne_dir}/{point_cloud_name}',
dtype=np.float32).reshape(-1, 4)
label = None
feed_dict = process_point_cloud(pc, label)
self.feed_dict = feed_dict
# 加载模型
predictions = self.LoadModel(feed_dict) # [n,] numpy array
logger.info("===> before set(predictions):{}".format(set(predictions)))
# 可视化
# self.visualize(feed_dict['pc'], predictions)
predictions+=1
logger.info("===> after set(predictions):{}".format(set(predictions)))
# 保存
self.saveBinLabel(f'{predictions_dir}/{label_name}', predictions)
from multiprocessing import cpu_count
from pathos.multiprocessing import ProcessingPool as Pool
print("===> CPU number: %d" % cpu_count())
pool = Pool(6)
pool.map(process, input_point_clouds)
pool.close()
pool.join()
'''
description:
param {*}
return {*} predictions array [n,]
param {*} self
param {*} feed_dict
'''
def LoadModel(self, feed_dict):
global device
# model = builder.make_model().to(device)
# logger.info(self.configs)
if self.configs.model == 'base_minkunet':
from core.models.semantic_kitti import BaseMinkUNet
# if 'cr' in configs.model:
# cr = configs.model.cr
# else:
# cr = 1.0
model = BaseMinkUNet(num_classes=19, cr=1.0)
elif self.configs.model == 'AF2S3_only_aff_Net':
from core.models.semantic_kitti.AF2S3_only_aff_Net import AF2S3_only_aff_Net
model = AF2S3_only_aff_Net(num_classes=19)
else:
raise NotImplementedError(self.configs.model)
model = model.to(device)
if self.configs.model == 'base_minkunet':
load_path = 'runs/run-98527c7b-864842b9/checkpoints/step-286980.pt'
elif self.configs.model == 'AF2S3_only_aff_Net':
load_path = 'runs/run-a5168cf1-b19bc802/checkpoints/step-286980.pt'
else:
raise NotImplementedError
state_dict = torch.load(load_path, map_location=device)['model']
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:] # remove `module.`，表面从第7个key值字符取到最后一个字符，正好去掉了module.
new_state_dict[name] = v #新字典的key值对应的value为一一对应的值。
# load params
model.load_state_dict(new_state_dict) # 从新加载这个模型。
model.eval()
with torch.no_grad():
inputs = feed_dict['lidar'].to(device)
outputs = model(inputs)
predictions = outputs.argmax(1).cpu().numpy()
predictions = predictions[feed_dict['inverse_map']]
logger.info("===> Finish model inference.")
torch.cuda.empty_cache()
logger.info("===> predictions.shape:{}".format(predictions.shape)) # array [n,]
logger.info("===> out_pc shape:{}".format(feed_dict['pc'].shape)) # array [n,4]
return predictions
'''
description:将array [n,]写入到bin中, 格式为np.uint32
param {*}
return {*}
param {*} self
param {*} labelFilename
param {*} predictions
'''
def saveBinLabel(self, labelFilename, predictions):
if os.path.exists(labelFilename):
logger.info("===> {} already exist, skip.".format(labelFilename.split("/")[-1]))
return
predictions.astype(np.uint32)
logger.info(predictions.shape)
logger.info(predictions.dtype)
def save_bin(binName, pred):
with open(binName, 'wb+') as binfile :
for i in range(pred.shape[0]):
class_label = pred[i]
class_label = int(class_label)
# logger.info("===> class_label:{}".format(class_label))
# logger.info("===> class_label:{}".format(class_label.type))
content = class_label.to_bytes(4, byteorder = 'little') # 4字节，小端
# logging.info({class_label:content})
# byt4 = (1).to_bytes(4, byteorder = 'big')
# print(byt4)
binfile.write(content )
# label_map_inv
label_map_inv = {
0: 0, # "unlabeled", and others ignored
1: 10, # "car"
2: 11, # "bicycle"
3: 15, # "motorcycle"
4: 18, # "truck"
5: 20, # "other-vehicle"
6: 30, # "person"
7: 31, # "bicyclist"
8: 32, # "motorcyclist"
9: 40, # "road"
10: 44, # "parking"
11: 48, # "sidewalk"
12: 49, # "other-ground"
13: 50, # "building"
14: 51, # "fence"
15: 70, # "vegetation"
16: 71, # "trunk"
17: 72, # "terrain"
18: 80, # "pole"
19: 81 # "traffic-sign"
}
# make lookup table for mapping
maxkey = max(label_map_inv.keys())
# +100 hack making lut bigger just in case there are unknown labels
remap_lut = np.zeros((maxkey + 100), dtype=np.int32)
remap_lut[list(label_map_inv.keys())] = list(label_map_inv.values())
# logger.info("remap_lut:{}".format(remap_lut))
predictions_inv = remap_lut[predictions]
# upper_half = np.zeros((predictions.shape), dtype=np.uint32)
# save_bin(labelFilename, predictions)
predictions_inv.astype(np.uint32)
logger.info("predictions:{}".format(set(predictions)))
logger.info("predictions_inv:{}".format(set(predictions_inv)))
predictions_inv.tofile(labelFilename)
logger.info('===> Save label file:{}'.format(labelFilename))
logger.info("*"*80)
# sem_label = self.loadBinLabel(labelFilename).reshape((-1))
# logger.info("sem_label:{}".format(set(sem_label)))
# self.visualize(self.feed_dict['pc'], sem_label)
pass
def loadBinLabel(self, labelFilename):
logger.info("===> Loading {}".format(labelFilename))
label = np.fromfile(labelFilename, dtype=np.uint32)
label = label.reshape((-1))
logger.info("===> [Load]label:{}".format(set(label)))
sem_label = label & 0xFFFF # 获取低16位信息
logger.info("===> [Load]sem_label :{}".format(set(sem_label)))
# label_map
remapdict = {
0 : 0, # "unlabeled"
1 : 0, # "outlier" mapped to "unlabeled" --------------------------mapped
10: 1, # "car"
11: 2, # "bicycle"
13: 5, # "bus" mapped to "other-vehicle" --------------------------mapped
15: 3, # "motorcycle"
16: 5, # "on-rails" mapped to "other-vehicle" ---------------------mapped
18: 4, # "truck"
20: 5, # "other-vehicle"
30: 6, # "person"
31: 7, # "bicyclist"
32: 8, # "motorcyclist"
40: 9, # "road"
44: 10, # "parking"
48: 11, # "sidewalk"
49: 12, # "other-ground"
50: 13, # "building"
51: 14, # "fence"
52: 0, # "other-structure" mapped to "unlabeled" ------------------mapped
60: 9, # "lane-marking" to "road" ---------------------------------mapped
70: 15, # "vegetation"
71: 16, # "trunk"
72: 17, # "terrain"
80: 18, # "pole"
81: 19, # "traffic-sign"
99: 0, # "other-object" to "unlabeled" ----------------------------mapped
252: 1, # "moving-car" to "car" ------------------------------------mapped
253: 7, # "moving-bicyclist" to "bicyclist" ------------------------mapped
254: 6, # "moving-person" to "person" ------------------------------mapped
255: 8, # "moving-motorcyclist" to "motorcyclist" ------------------mapped
256: 5, # "moving-on-rails" mapped to "other-vehicle" --------------mapped
257: 5, # "moving-bus" mapped to "other-vehicle" -------------------mapped
258: 4, # "moving-truck" to "truck" --------------------------------mapped
259: 5 # "moving-other"-vehicle to "other-vehicle" ----------------mapped
}
# make lookup table for mapping
maxkey = max(remapdict.keys())
# +100 hack making lut bigger just in case there are unknown labels
remap_lut = np.zeros((maxkey + 100), dtype=np.int32)
remap_lut[list(remapdict.keys())] = list(remapdict.values())
# logger.info(remap_lut)
sem_label_mapped = remap_lut[sem_label] # do the remapping of semantics
logger.info("===> [Load]sem_label_mapped :{}".format(set(sem_label_mapped)))
sem_label_mapped-=1
return sem_label_mapped
pass
def visualize(self, pc, label):
logger.info("===> visualize...")
cmap = np.array([
[245, 150, 100, 255],
[245, 230, 100, 255],
[150, 60, 30, 255],
[180, 30, 80, 255],
[255, 0, 0, 255],
[30, 30, 255, 255],
[200, 40, 255, 255],
[90, 30, 150, 255],
[255, 0, 255, 255],
[255, 150, 255, 255],
[75, 0, 75, 255],
[75, 0, 175, 255],
[0, 200, 255, 255],
[50, 120, 255, 255],
[0, 175, 0, 255],
[0, 60, 135, 255],
[80, 240, 150, 255],
[150, 240, 255, 255],
[0, 0, 255, 255],
])
cmap = cmap[:, [2, 1, 0, 3]] # convert bgra to rgba
color_dict = {}
for i in range(19):
color_dict[i] = cmap[i, :]
color_dict[255] = [0,0,0,255]
pct = o3d.geometry.PointCloud()
pct.points = o3d.utility.Vector3dVector(pc[:,:-1])
cloud_color = [color_dict[i] for i in list(label)]
color = np.array(cloud_color).reshape((-1,4))[:,:3] / 255
pct.colors = o3d.utility.Vector3dVector(color)
o3d.visualization.draw_geometries([pct], top=0, left=0)
def loadConfig():
parser = argparse.ArgumentParser('Model')
parser.add_argument('--model', type=str, default='AF2S3_only_aff_Net')
parser.add_argument('--sequence', type=int, default=11)
parser.add_argument('--device', type=int, default=0)
parser.add_argument('--outDIR', type=str, default='submission_dir')
args = parser.parse_args()
return args
def main():
global device
args = loadConfig()
if args.device==1:
device = 'cuda:1'
elif args.device == 0:
device = 'cuda:0'
else:
device = 'cpu'
root_path = '/mnt/software/suyunzheng/data/semantic-kitti/sequences'
eval = kittiEval(root_path=root_path, configs=args)
# for sequence in tqdm(range(13, 22)):
# logger.info("===> current sequence:{}".format(sequence))
# eval.get_pred(sequence=sequence)
logger.info("===> current sequence:{}".format(args.sequence))
eval.get_pred(sequence=args.sequence)
if __name__ =='__main__':
main()
2、压缩生成zip文件
zip -r zip_name.zip ./
3、使用脚本验证zip文件完整性
参考：
https://github.com/PRBonn/semantic-kitti-api/blob/master/validate_submission.py
./validate_submission.py \
/mnt/software/suyunzheng/data/semantic-kitti/submission/submission3.zip \
/mnt/software/suyunzheng/data/semantic-kitti/
4、提交
https://competitions.codalab.org/competitions
1343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
