本篇文章承接上文，主要阐述代码，分布的成果等工作。识别结果为单帧图片，每一张图片识别完之后，放在一起，就可以连续播放单帧文件，变成视频，或者直接在matlab图窗里面播放。关于这个函数的功能我会在下一篇文章中进行介绍，感兴趣可以点个关注，去我主页看，或者直接下载资源：传送门。偶尔在平台上回复不及时，可以来找我咨询或下载
注意，要成功复现本项目需要准备好matlab2020a以上版本以及python3.0环境，最好准备好cuda环境，可以大幅度降低大数据训练的时间，没有也没关系，准备好后可以进行接下来的内容啦。
开始正文
数据准备
准备训练集和数据集，训练集包括以下文件：
如果你下载的是我准备好的200个测试文件，那么应该包含如下内容：
测试集如下所示，你可以从训练集随机选取一些作为测试集，也可以使用我打包好的文件。
对于calib的标签文件，我选择了一个放在里面，感兴趣的可以选其他的calib放在里面，当然，你也可以去德国图宾根官网下载数据，同样适用于我们的项目！(前提是要会ladder,想要更多数据的可以联系我q2504953121，路况包括不限于田野，交通路口，高架桥，高校校园等复杂路况。)
数据集可视化
clc; clear; close all;
file = '000264'; % 文件编号
fid=fopen(['./training/velodyne/',file,'.bin'],'rb');
[a,count]=fread(fid,'float32');
fclose(fid);
x = a(1:4:end);
y = a(2:4:end);
z = a(3:4:end);
reflectivity = a(4:4:end);
point_cloud = [x,y,z,reflectivity];
data = pointCloud([x y z]);
figure(11);
pcshow(data);hold on;
label = importdata(['./training/label/',file,'.txt']);
obsName = label.textdata;
data_label = label.data;
obsNum = size(data_label,1); % 包含DontCare类障碍物的总个数
obsCount = 0; % 初始化不包含DontCare类障碍物个数为0
data_calib = importdata(['./training/calib/',file,'.txt']);
Tr_velo_to_cam = reshape(data_calib.data(end-1,:),[4,3])';
Tr_velo_to_cam = [Tr_velo_to_cam;0 0 0 1];
pos = {}; % 创建一个cell数组用于存储障碍物坐标
for i = 1:obsNum
if obsName{i} == "DontCare"
continue;
end
obsCount = obsCount + 1;
la = data_label(i,:);
obsPos = la(11:13)';
[h,w,l] = deal(la(8),la(9),la(10));
r_y = la(end);
% obsPos_velo = Tr_cam_to_velo*[obsPos;1];
% obsPos_velo = obsPos_velo(1:3)
% t1~t8为障碍物坐标系下的坐标（不考虑障碍物旋转，默认长边与x-axis平行）
t1 = [l/2,0,w/2];
t2 = [l/2,0,-w/2];
t3 = [l/2,-h,w/2];
t4 = [l/2,-h,-w/2];
t5 = [-l/2,0,w/2];
t6 = [-l/2,0,-w/2];
t7 = [-l/2,-h,w/2];
t8 = [-l/2,-h,-w/2];
% 考虑障碍物旋转角度r_y，对x,z方向进行更新
T = [t1;t2;t3;t4;t5;t6;t7;t8];
R = [cos(r_y),-sin(r_y);sin(r_y),cos(r_y)];
T(:,[1,3]) = (R*T(:,[1,3])')';
% 考虑障碍物坐标系与相机坐标系坐标位移
T(:,1) = T(:,1) + obsPos(1);
T(:,2) = T(:,2) + obsPos(2);
T(:,3) = T(:,3) + obsPos(3);
% 将相机坐标系转化到激光雷达坐标系
velo_pos = Tr_velo_to_cam\[T';1,1,1,1,1,1,1,1];
velo_pos = velo_pos(1:3,:);
% 记录障碍Box坐标
pos{i} = velo_pos;
% 绘制12根线构成3D-Box
temp = [velo_pos(:,3),velo_pos(:,4),velo_pos(:,7),velo_pos(:,8)];
[~,j] = max([velo_pos(1,3),velo_pos(1,4),velo_pos(1,7),velo_pos(1,8)]);
textPoint = temp(:,j);
text(textPoint(1),textPoint(2),textPoint(3)+0.5,obsName{i},'Color','white');
plot3(velo_pos(1,[1,2,6,5,1]),velo_pos(2,[1,2,6,5,1]),velo_pos(3,[1,2,6,5,1]),'Color','r');
plot3(velo_pos(1,[3,4,8,7,3]),velo_pos(2,[3,4,8,7,3]),velo_pos(3,[3,4,8,7,3]),'Color','r');
plot3(velo_pos(1,[1,3]),velo_pos(2,[1,3]),velo_pos(3,[1,3]),'Color','r');
plot3(velo_pos(1,[2,4]),velo_pos(2,[2,4]),velo_pos(3,[2,4]),'Color','r');
plot3(velo_pos(1,[6,8]),velo_pos(2,[6,8]),velo_pos(3,[2,4]),'Color','r');
plot3(velo_pos(1,[5,7]),velo_pos(2,[5,7]),velo_pos(3,[5,7]),'Color','r');
end
结果如下：主要实现的功能是选取一个训练集可视化，看一下标签，即机动车是什么类型的车，并把点云数据标红。
障碍物点云提取
figure(2);
row = ceil(obsCount / 3);
[n,~] = size(point_cloud);
for k = 1:obsCount
[max_x,~] = max(pos{k}(1,[1,2,5,6]));
[min_x,~] = min(pos{k}(1,[1,2,5,6]));
[max_y,~] = max(pos{k}(2,[1,2,5,6]));
[min_y,~] = min(pos{k}(2,[1,2,5,6]));
point_selected = [];
for i = 1:n
if point_cloud(i,1)>min_x && point_cloud(i,1)<max_x...
&& point_cloud(i,2)>min_y && point_cloud(i,2)<max_y
point_selected = [point_selected;point_cloud(i,:)];
end
end
subplot(row,3,k);
data = pointCloud([point_selected(:,1),point_selected(:,2),point_selected(:,3)]);
pcshow(data);hold on;
title(obsName{k});
end
结果如下：主要实现的功能是把此数据集中包含的车辆拿出来，就像在橱窗里面展示玩具车一样。
非地面点云分割
这里对点云分割有两种方法
第一种 RANSAC算法去除地面点云
options.epsilon = 1e-6;
options.P_inlier = 0.90;
options.sigma = 0.01;
options.T_noise_squared = 0.002;
options.est_fun = @estimate_plane;
options.man_fun = @error_plane;
options.mode = 'MSAC';
options.Ps = [];
options.notify_iters = [];
options.min_iters = 1000;
options.fix_seed = false;
options.reestimate = true;
options.stabilize = false;
processed_point_cloud = point_cloud((point_cloud(:,3)<-1)&(point_cloud(:,3)>-2.5),:);
temp = 1:size(point_cloud,1);
index = temp(point_cloud(:,3)<0);
[results, options] = RANSAC(processed_point_cloud', options);
ind = results.CS;
plane_cloud_point = processed_point_cloud(ind,:);
figure(3);
data = pointCloud([plane_cloud_point(:,1),plane_cloud_point(:,2),plane_cloud_point(:,3)]);
pcshow(data);hold on;
title('The plane point cloud')
figure(4);
temp1 = index(ind);
temp2 = 1:size(point_cloud,1);
temp2(temp1) = [];
not_plane_cloud_point = point_cloud(temp2,:);
data = pointCloud([not_plane_cloud_point(:,1),not_plane_cloud_point(:,2),not_plane_cloud_point(:,3)]);
pcshow(data);hold on;
title('The point cloud without plane')
第二种 直接按照高度去除地面点云
figure(5);
processed_point_cloud = point_cloud(point_cloud(:,3)>-1.5,:);
data = pointCloud(processed_point_cloud(:,1:3));
pcshow(data);hold on;
两种的得到的效果类似(英文题目为ransac效果，中文题目为直接按照高度去除)，如下：主要实现的功能是把此数据集中包含的地面反射的点云去除，否则十分影响我们的车辆识别。
-
地上的点云
上下图不是一个时刻的文件
-
去除地面后的点云
点云栅格化
xmin = -20; xmax = 20; ymin = -10; ymax = 10;
d = 0.5; % 1m*1m栅格尺寸 需要整除xmin and xmax and ymin and ymax
gridcell = cell((xmax-xmin)/d,(ymax-ymin)/d); % 定义栅格存储cell
for i = 1:size(processed_point_cloud,1)
point = processed_point_cloud(i,:);
if point(1)>=xmax || point(1)<=xmin || point(2)>=ymax || point(2)<=ymin
continue;
end
xgrid = ceil((point(1)-xmin)/d);
ygrid = ceil((point(2)-ymin)/d);
gridcell{xgrid,ygrid} = [gridcell{xgrid,ygrid};point];
end
% 判断有障碍物的栅格将其保留，其余删除
threshold_deltaZ = 0.3;
threshold_point_num = 10;
for i = 1:(xmax-xmin)/d
for j = 1:(ymax-ymin)/d
if isempty(gridcell{i,j})
continue;
end
cell_point_count = size(gridcell{i,j},1);
deltaZ = max(gridcell{i,j}(:,3))-min(gridcell{i,j}(:,3));
if deltaZ < threshold_deltaZ || cell_point_count < threshold_point_num
gridcell{i,j} = [];
end
end
end
figure(6);
for i = 1:(xmax-xmin)/d
for j = 1:(ymax-ymin)/d
if isempty(gridcell{i,j})
continue;
end
scatter(gridcell{i,j}(:,1),gridcell{i,j}(:,2),1,'r.'); hold on;
end
end
title('经过栅格化并去除多余点后的二维点云图')
set(gca,'XTick',xmin:d:xmax,'YTick',ymin:d:ymax); % 绘制网格
grid on;
得到的结果如下：主要实现的功能是把此数据集中非地面点云的数据按照一定尺寸(我用的是40*20)将点云栅格化，并呈现在二维图中。
非地面栅格点云聚类
我们利用密度聚类(DBSCAN)
cellIndexNotEmpty = []; % 保存非空的cell的(i,j)
ub = [(xmax-xmin)/d,(ymax-ymin)/d];
lb = [1,1];
for i = 1:ub(1)
for j = 1:ub(2)
if isempty(gridcell{i,j})
continue;
end
cellIndexNotEmpty = [cellIndexNotEmpty;i,j 0]; %第三个分量表示栅格是否被访问
end
end
C = {}; % 聚类类别的cell数组
MinPts = 45; % DBSCAN 参数，领域最小对象数
while any(cellIndexNotEmpty(:,3)==0)
unvisited_grids = cellIndexNotEmpty(cellIndexNotEmpty(:,3)==0,:);
random_index = randperm(size(unvisited_grids,1),1);
p = unvisited_grids(random_index,1:2);
cellIndexNotEmpty(cellIndexNotEmpty(:,1)==p(1)&cellIndexNotEmpty(:,2)==p(2),3) = 1; % 标记被访问
neighborhood = [p(1)+1,p(2);p(1)-1,p(2);p(1),p(2)-1;p(1),p(2)+1;...
p(1)-1,p(2)-1;p(1)-1,p(2)+1;p(1)+1,p(2)-1;p(1)+1,p(2)+1];
point_num = 0;
delete_index = [];
for i = 1:size(neighborhood,1)
flag_ub = neighborhood(i,:)>ub;
flag_lb = neighborhood(i,:)<lb;
if any(flag_lb+flag_ub)
delete_index = [delete_index,i];
continue;
end
if isempty(gridcell{neighborhood(i,1),neighborhood(i,2)})
delete_index = [delete_index,i];
continue;
end
neighbor = neighborhood(i,:);
point_num = point_num + size(gridcell{neighbor(1),neighbor(2)},1);
end
neighborhood(delete_index,:) = [];
if point_num >= MinPts
if isempty(C)
C = {p};
else
C{end+1} = p;
end
while ~isempty(neighborhood)
neighbor = neighborhood(1,:);
neighborhood(1,:) = [];
if cellIndexNotEmpty(cellIndexNotEmpty(:,1)==neighbor(1)&...
cellIndexNotEmpty(:,2)==neighbor(2),3) == 0
cellIndexNotEmpty(cellIndexNotEmpty(:,1)==neighbor(1)&...
cellIndexNotEmpty(:,2)==neighbor(2),3) = 1; % 标记被访问
neighborhood_ = [neighbor(1)+1,neighbor(2);neighbor(1)-1,neighbor(2);...
neighbor(1),neighbor(2)-1;neighbor(1),neighbor(2)+1;...
neighbor(1)-1,neighbor(2)-1;neighbor(1)-1,neighbor(2)+1;...
neighbor(1)+1,neighbor(2)-1;neighbor(1)+1,neighbor(2)+1];
point_num = 0;
delete_index = [];
for k = 1:size(neighborhood_,1)
flag_ub = neighborhood_(k,:)>ub;
flag_lb = neighborhood_(k,:)<lb;
if any(flag_lb+flag_ub)
delete_index = [delete_index,k];
continue;
end
if isempty(gridcell{neighborhood_(k,1),neighborhood_(k,2)})
delete_index = [delete_index,k];
continue;
end
neighbor_ = neighborhood_(k,:);
point_num = point_num + size(gridcell{neighbor_(1),neighbor_(2)},1);
end
neighborhood_(delete_index,:) = [];
if point_num >= MinPts
neighborhood = [neighborhood;neighborhood_];
flag = false;
for m = 1:size(C,2)
temp = C{m};
if any(temp(:,1)==neighbor(1)&temp(:,2)==neighbor(2))
flag = true;
break;
end
end
if ~flag
C{end} = [C{end};neighbor];
end
end
end
end
end
end
cluster = {}; % 存放不同类别点云坐标
figure(7);
for i = 1:size(C,2)
temp = C{i};
t2 = [];
for j = 1:size(temp,1)
t = temp(j,:);
x_lb = (t(1)-1)*d+xmin; x_ub = t(1)*d+xmin;
y_lb = (t(2)-1)*d+ymin; y_ub = t(2)*d+ymin;
t1 = point_cloud(:,1)>=x_lb & point_cloud(:,1)<=x_ub...
& point_cloud(:,2)>=y_lb & point_cloud(:,2)<=y_ub...
& point_cloud(:,3)>-1.5;
t2 = [t2;point_cloud(t1,:)];
end
if isempty(cluster)
cluster = {t2};
else
cluster{end+1} = t2;
end
scatter(t2(:,1),t2(:,2),1); hold on;
text(max(t2(:,1)),max(t2(:,2)),num2str(i))
end
cluster % 显示聚类结果
结果如下：主要实现的功能是二维把点聚类，就是把接近的放在一堆，要不就是一堆散的点了，你们看，效果还是十分不错的，当然还有另外两种聚类方法，如果你使用成功的话欢迎给我留言或@我。
用python训练模型
为了方便你们使用，我已经新建好了项目，可以直接使用Visual Studio打开，或者直接用VScode打开main.py即可，我的Visual Studio版本为2017。
- 先在matlab中获取好要训练的点云数据
我的文件里已经批量处理好了。
files = dir("./training/velodyne/*.bin");
car_point = {}; % 存储car障碍点云元胞
pedestrian_point = {}; % 存储pedestrain障碍点云元胞
cyclist_point = {}; % 存储cyclist障碍点云元胞
misc_point = {}; % 存储杂项障碍点云元胞
load_file_num = 200; % 读取的点云文件数
for k = 1:load_file_num
filename = files(k).name;
fid=fopen(['./training/velodyne/',filename],'rb');
[a,count]=fread(fid,'float32');
fclose(fid);
x = a(1:4:end);
y = a(2:4:end);
z = a(3:4:end);
reflectivity = a(4:4:end); % 反射率
point_cloud = [x,y,z,reflectivity];
label = importdata(['./training/label/',filename(1:6),'.txt']);
data_label = label.data;
obsName = label.textdata;
data_calib = importdata(['./training/calib/',filename(1:6),'.txt']);
Tr_velo_to_cam = reshape(data_calib.data(end-1,:),[4,3])';
Tr_velo_to_cam = [Tr_velo_to_cam;0 0 0 1];
pos = {}; % 创建一个cell数组用于存储障碍物坐标
obsNum = size(obsName,1); % 包含DontCare类障碍物的总个数
for i = 1:obsNum
if obsName{i} == "DontCare"
continue;
end
la = data_label(i,:);
obsPos = la(11:13)';
[h,w,l] = deal(la(8),la(9),la(10));
r_y = la(end);
% t1~t8为障碍物坐标系下的坐标（不考虑障碍物旋转，默认长边与x-axis平行）
t1 = [l/2,0,w/2];
t2 = [l/2,0,-w/2];
t3 = [l/2,-h,w/2];
t4 = [l/2,-h,-w/2];
t5 = [-l/2,0,w/2];
t6 = [-l/2,0,-w/2];
t7 = [-l/2,-h,w/2];
t8 = [-l/2,-h,-w/2];
% 考虑障碍物旋转角度r_y，对x,z方向进行更新
T = [t1;t2;t3;t4;t5;t6;t7;t8];
R = [cos(r_y),-sin(r_y);sin(r_y),cos(r_y)];
T(:,[1,3]) = (R*T(:,[1,3])')';
% 考虑障碍物坐标系与相机坐标系坐标位移
T(:,1) = T(:,1) + obsPos(1);
T(:,2) = T(:,2) + obsPos(2);
T(:,3) = T(:,3) + obsPos(3);
% 将相机坐标系转化到激光雷达坐标系
velo_pos = Tr_velo_to_cam\[T';1,1,1,1,1,1,1,1];
velo_pos = velo_pos(1:3,:);
% 记录障碍Box坐标
pos{i} = velo_pos;
end
[n,~] = size(point_cloud);
for i = 1:obsNum
if obsName{i} == "DontCare"
continue;
end
[max_x,~] = max(pos{i}(1,[1,2,5,6]));
[min_x,~] = min(pos{i}(1,[1,2,5,6]));
[max_y,~] = max(pos{i}(2,[1,2,5,6]));
[min_y,~] = min(pos{i}(2,[1,2,5,6]));
la = data_label(i,:);
[h,w,l] = deal(la(8),la(9),la(10));
point_selected = [];
for j = 1:n
if point_cloud(j,1)>min_x && point_cloud(j,1)<max_x...
&& point_cloud(j,2)>min_y && point_cloud(j,2)<max_y && point_cloud(j,3)>-1.5
point_selected = [point_selected;point_cloud(j,:)];
end
end
point_selected = [l,w,h,0;point_selected]; % 数据集第一行数据为[l w h 0],0只是占位
if obsName{i} == "Car" && size(point_selected,1)>200
if isempty(car_point)
car_point = {point_selected};
else
car_point{end+1} = point_selected;
end
end
if obsName{i} == "Pedestrian" && size(point_selected,1)>100
if isempty(pedestrian_point)
pedestrian_point = {point_selected};
else
pedestrian_point{end+1} = point_selected;
end
end
if obsName{i} == "Cyclist" && size(point_selected,1)>100
if isempty(cyclist_point)
cyclist_point = {point_selected};
else
cyclist_point{end+1} = point_selected;
end
end
if obsName{i} == "Misc" && size(point_selected,1)>40
if isempty(misc_point)
misc_point = {point_selected};
else
misc_point{end+1} = point_selected;
end
end
end
end
figure(8);
pcshow(pointCloud(misc_point{3}(2:end,1:3)))
for i = 1:size(car_point,2)
writematrix(car_point{i},['./training/car/',num2str(i),'.csv']);
end
for i = 1:size(pedestrian_point,2)
writematrix(pedestrian_point{i},['./training/pedestrian/',num2str(i),'.csv']);
end
for i = 1:size(cyclist_point,2)
writematrix(cyclist_point{i},['./training/cyclist/',num2str(i),'.csv']);
end
for i = 1:size(misc_point,2)
writematrix(misc_point{i},['./training/misc/',num2str(i),'.csv']);
end
结果如图：
- 测试神经网络分类器（保存聚类结果csv供Python测试）
% cluster点云存储
for i = 1:size(cluster,2)
temp = cluster{i};
max_x = max(temp(:,1));
min_x = min(temp(:,1));
max_y = max(temp(:,2));
min_y = min(temp(:,2));
h = max(temp(:,3)) - min(temp(:,3));
if max_x - min_x > max_y - min_y
l = max_x - min_x;
w = max_y - min_y;
else
l = max_y - min_y;
w = max_x - min_x;
end
writematrix([l,w,h,0;temp],['./testing/cluster/',num2str(i),'.csv']);
end
- 在python中训练识别模型，并评估其效果
设置了400代，在训练中得到model_state_dict.pkl，并有两个测试函数。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
"""
Date: 2023.4.23
Author: A-Kang
"""
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import torch
from torch import nn
import pandas as pd
import numpy as np
import os
feature_dim = 按需求设置
device = 'cuda' if torch.cuda.is_available() else 'cpu'
def feature_extract(filename):
data = pd.read_csv(filename,header=None).to_numpy(dtype=float)
point_cloud = data[1:,0:3]
ref = data[1:,3]
[l,w,h,_] = data[0,:]
max_x,min_x = np.max(point_cloud[:,0]),np.min(point_cloud[:,0])
max_y, min_y = np.max(point_cloud[:,1]), np.min(point_cloud[:,1])
# f1 = np.array([l,w,h]) # 第一个特征
f1 = np.array([h]) # 仅用h效果好些
slices_num = 10
if max_x-min_x > max_y-min_y:
t = np.linspace(min_x,max_x,slices_num+1) # slices_num+1个值构成slices_num个区间
flag = 0
else:
t = np.linspace(min_y, max_y, slices_num+1)
flag = 1
f2 = []
for i in range(len(t)-1):
lb,ub = t[i],t[i+1]
sum_h,num = 0,0
for point in point_cloud:
if lb < point[flag] < ub:
sum_h += point[2]
num += 1
f2.append(sum_h/num if num!=0 else 0)
f2 = np.array(f2) # 第二个特征
f3 = np.array([(max_x-min_x if flag==1 else max_y-min_y)/h]) # 第三个特征
f4 = np.array([np.mean(ref),np.std(ref)]) # 第四个特征
num1,num2 = 0,0
for r in ref:
if 0<=r<0.2:
num1 += 1
if 0.2<=r<0.4:
num2 += 1
f5 = np.array([(num1 - num2) / point_cloud.shape[0]]) # 第五个特征
feature = np.concatenate((f1,f2,f3,f4,f5))
return feature
def load_data():
data_car = np.array([[]],dtype=float).reshape(-1,feature_dim)
for file in os.listdir('./training/car'):
data_car = np.concatenate((data_car,feature_extract('./training/car/'+file).reshape(1,-1)),axis=0)
label_car = np.zeros((data_car.shape[0],),dtype=float) # car标记为0
data_pedestrian = np.array([[]], dtype=float).reshape(-1, feature_dim)
for file in os.listdir('./training/pedestrian'):
data_pedestrian = np.concatenate((data_pedestrian, feature_extract('./training/pedestrian/' + file).reshape(1, -1)), axis=0)
label_pederstian = 1+np.zeros((data_pedestrian.shape[0],), dtype=float) # pedestrian标记为1
data_cyclist = np.array([[]], dtype=float).reshape(-1, feature_dim)
for file in os.listdir('./training/cyclist'):
data_cyclist = np.concatenate((data_cyclist, feature_extract('./training/cyclist/' + file).reshape(1, -1)),axis=0)
label_cyclist = 1+np.zeros((data_cyclist.shape[0],), dtype=float) # cyclist标记为2
data_others = np.array([[]], dtype=float).reshape(-1, feature_dim)
for file in os.listdir('./training/others'):
data_others = np.concatenate((data_others, feature_extract('./training/others/' + file).reshape(1, -1)),axis=0)
label_others = 1 + np.zeros((data_others.shape[0],), dtype=float) # others标记为3
total_data = np.concatenate((data_car,data_pedestrian,data_cyclist,data_others),axis=0)
total_label = np.concatenate((label_car,label_pederstian,label_cyclist,label_others))
train_x,test_x,train_y,test_y = train_test_split(total_data,total_label)
train_x = torch.from_numpy(train_x).type(torch.float32).to(device)
train_y = torch.from_numpy(train_y).type(torch.LongTensor).to(device)
test_x = torch.from_numpy(test_x).type(torch.float32).to(device)
test_y = torch.from_numpy(test_y).type(torch.LongTensor).to(device)
class Mydataset(torch.utils.data.Dataset):
def __init__(self, features, labels):
self.features = features
self.labels = labels
def __getitem__(self, index):
feature = self.features[index]
label = self.labels[index]
return feature, label
def __len__(self):
return len(self.features)
train_ds = Mydataset(train_x, train_y)
test_ds = Mydataset(test_x, test_y)
BTACH_SIZE = 256
train_dl = torch.utils.data.DataLoader(
train_ds,
batch_size=BTACH_SIZE,
shuffle=True)
test_dl = torch.utils.data.DataLoader(
test_ds,
batch_size=BTACH_SIZE,
shuffle=True)
print('=====load data finished!+=====')
return train_dl,test_dl,(train_ds,test_ds)
def get_model():
class Model(nn.Module):
def __init__(self,dim):
super().__init__()
self.liner_1 = nn.Linear(dim,256)
self.liner_2 = nn.Linear(256,256)
self.liner_3 = nn.Linear(256,2)
self.relu = nn.LeakyReLU()
def forward(self,feature):
x = self.liner_1(feature)
x = self.relu(x)
x = self.liner_2(x)
x = self.relu(x)
x = self.liner_3(x)
return x
model = Model(feature_dim).to(device)
opt = torch.optim.Adam(model.parameters(),lr=1e-4)
loss_fn = nn.CrossEntropyLoss()
return model,opt,loss_fn
def save_model_para(model):
import scipy.io as scio
var_name = list()
for name,para in model.named_parameters():
x = name.split(".")
para_name = x[0] + "_" + x[1]
exec(para_name + '=para.cpu().data.numpy()')
print(name)
var_name.append(para.cpu().data.numpy())
data_file = 'para_save_open.mat'
scio.savemat(data_file,
{'l1_weight': var_name[0], 'l1_bias': var_name[1], 'l2_weight': var_name[2], 'l2_bias': var_name[3],
'l3_weight': var_name[4], 'l3_bias': var_name[5],
})
def test():
model = get_model()[0]
model.load_state_dict(torch.load('model_state_dict.pkl',map_location='cpu'))
test_feature = np.array([[]], dtype=float).reshape(-1, feature_dim)
test_data = list()
for file in os.listdir('./testing/cluster'):
data = pd.read_csv("".join(['./testing/cluster/',file]), header=None).to_numpy(dtype=float)
test_data.append(data)
feature = feature_extract("".join(['./testing/cluster/',file]))
test_feature = np.concatenate((test_feature,feature.reshape(1,-1)),axis=0)
test_x = torch.from_numpy(test_feature).type(torch.float32).to(device)
model.eval()
plt.figure(2)
plt.scatter(0,0,s=20)
with torch.no_grad():
output = model(test_x)
y_pred = torch.argmax(output,dim=1).cpu().detach().numpy()
# points_dict = {'Car':np.array([]),'Pedestrian':np.array([]),'Cyclist':np.array([]),'Others':np.array([])}
# category_list = ['Car','Pedestrian','Cyclist','Others']
points_dict = {'Car':np.array([]),'Others':np.array([])}
category_list = ['Car','Others']
for i,val in enumerate(y_pred):
points_dict[category_list[val]] = np.append(points_dict[category_list[val]],test_data[i][1:,0:3])
for ca in category_list:
points = points_dict[ca].reshape(-1,3)
plt.scatter(points[:,0],points[:,1],s=np.ones(len(points),))
leg = ['Coordinate origin of lidar']
leg.extend(category_list)
plt.legend(leg)
plt.show()
def test2():
model = get_model()[0]
model.load_state_dict(torch.load('model_state_dict.pkl',map_location='cpu'))
test_feature = np.array([[]], dtype=float).reshape(-1, feature_dim)
test_data = list()
for file in os.listdir('./training/pedestrian'):
data = pd.read_csv("".join(['./training/pedestrian/', file]), header=None).to_numpy(dtype=float)
test_data.append(data)
feature = feature_extract("".join(['./training/pedestrian/', file]))
test_feature = np.concatenate((test_feature, feature.reshape(1, -1)), axis=0)
test_x = torch.from_numpy(test_feature).type(torch.float32).to(device)
model.eval()
with torch.no_grad():
output = model(test_x)
y_pred = torch.argmax(output, dim=1).cpu().detach().numpy()
print((y_pred==np.ones(len(y_pred),).mean()))
def main():
train_dl,test_dl,(train_ds,test_ds) = load_data()
model,opt,loss_fn = get_model()
def accuracy(y_pred,y_true):
y_pred = torch.argmax(y_pred,dim=1)
acc = (y_pred == y_true).float().mean()
return acc
epochs = 400
loss_list = []
accuracy_list = []
test_loss_list = []
test_accuarcy_list = []
for epoch in range(epochs):
model.train()
for x, y in train_dl:
if torch.cuda.is_available():
x, y = x.to('cuda'), y.to('cuda')
y_pred = model(x)
loss = loss_fn(y_pred, y)
opt.zero_grad()
loss.backward()
opt.step()
model.eval()
with torch.no_grad():
epoch_accuracy = accuracy(model(train_ds.features), train_ds.labels)
epoch_loss = loss_fn(model(train_ds.features), train_ds.labels).data
epoch_test_accuracy = accuracy(model(test_ds.features), test_ds.labels)
epoch_test_loss = loss_fn(model(test_ds.features), test_ds.labels).data
loss_list.append(round(epoch_loss.item(), 3))
accuracy_list.append(round(epoch_accuracy.item(), 3))
test_loss_list.append(round(epoch_test_loss.item(), 3))
test_accuarcy_list.append(round(epoch_test_accuracy.item(), 3))
print('epoch: ', epoch, 'loss： ', round(epoch_loss.item(), 3),
'accuracy:', round(epoch_accuracy.item(), 3),
'test_loss： ', round(epoch_test_loss.item(), 3),
'test_accuracy:', round(epoch_test_accuracy.item(), 3)
)
save_model_para(model)
torch.save(model.state_dict(),'model_state_dict.pkl')
plt.figure(1)
plt.plot(range(0, epochs), loss_list, 'r', label='Training loss')
plt.plot(range(0, epochs), accuracy_list, 'g', label='Training accuracy')
plt.plot(range(0, epochs), test_loss_list, 'b', label='Test loss')
plt.plot(range(0, epochs), test_accuarcy_list, 'k', label='Test accuracy')
plt.title('Training and Validation Loss')
plt.xlabel('Epoch')
plt.legend()
plt.show()
if __name__ == "__main__":
def setup_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed)
torch.backends.cudnn.deterministic = True
setup_seed(自己按需求设置)
main()
test()
结果可以看到在200代的时候基本识别精度已经99%了。
这是识别后的py可视化：
运行过程：
利用训练好的模型在matlab中识别
加载Python得到的模型参数-前向传播，在matlab中运行
load('para_save_open.mat');
figure(9);
data = pointCloud(point_cloud(:,1:3));
pcshow(data);hold on;
figure(10);
for i = 1:size(cluster,2)
temp = cluster{i};
max_x = max(temp(:,1));
min_x = min(temp(:,1));
max_y = max(temp(:,2));
min_y = min(temp(:,2));
h = max(temp(:,3)) - min(temp(:,3));
if max_x - min_x > max_y - min_y
l = max_x - min_x;
w = max_y - min_y;
else
l = max_y - min_y;
w = max_x - min_x;
end
f = feature_extract([l,w,h,0;temp]);%%
res = policy_net_sign_bankangle(f');
[~,index] = max(res,[],1);
if index == 1
figure(9);
scatter3(temp(:,1),temp(:,2),temp(:,3),1,'r.');
figure(10);
bar1 = scatter(temp(:,1),temp(:,2),1,'r.'); hold on;
elseif index == 2
figure(10);
bar2 = scatter(temp(:,1),temp(:,2),1,'b.');hold on;
end
end
figure(9);
title("最终分类结果（红点表示Car点云）")
figure(10);
legend([bar1,bar2],["Car","Others"]);
title('检测结果')
结果如下：主要实现的功能是识别结果可视化，把点云数据标红。
我们学校某路段结果：
查看训练结果在物理世界是什么样子的
figure()
Image = imread(['./training/image_2/',file,'.png']);
imshow(Image); hold on;
P2 = reshape(data_calib.data(3,:),[4,3])';
R0_rect = reshape(data_calib.data(5,1:end-3),[3,3])';
R0_rect = [R0_rect,[0;0;0];[0,0,0,1]];
for i = 1:obsNum
if obsName{i} == "DontCare"
continue;
end
la = data_label(i,:);
obsPos = la(11:13)';
[h,w,l] = deal(la(8),la(9),la(10));
r_y = la(end);
% t1~t8为障碍物坐标系下的坐标（不考虑障碍物旋转，默认长边与x-axis平行）
t1 = [l/2,0,w/2];
t2 = [l/2,0,-w/2];
t3 = [l/2,-h,w/2];
t4 = [l/2,-h,-w/2];
t5 = [-l/2,0,w/2];
t6 = [-l/2,0,-w/2];
t7 = [-l/2,-h,w/2];
t8 = [-l/2,-h,-w/2];
% 考虑障碍物旋转角度r_y，对x,z方向进行更新
T = [t1;t2;t3;t4;t5;t6;t7;t8];
R = [cos(r_y),-sin(r_y);sin(r_y),cos(r_y)];
T(:,[1,3]) = (R*T(:,[1,3])')';
% 考虑障碍物坐标系与相机坐标系坐标位移
T(:,1) = T(:,1) + obsPos(1);
T(:,2) = T(:,2) + obsPos(2);
T(:,3) = T(:,3) + obsPos(3);
T = [T';1,1,1,1,1,1,1,1];
res = P2*R0_rect*T; % 从参考相机坐标系到左彩色相机图像坐标
for j = 1:size(res,2)
res(:,j) = res(:,j)/res(3,j);
end
res = res(1:2,:);
% 绘制12根线构成3D-Box
temp = res(:,[3,4,8,7]);
[~,j] = min(res(2,[3,4,8,7]));
textPoint = temp(:,j);
text(textPoint(1),textPoint(2)-10,obsName{i},'Color','green');
plot(res(1,[1,2,6,5,1]),res(2,[1,2,6,5,1]),'Color','r');
plot(res(1,[3,4,8,7,3]),res(2,[3,4,8,7,3]),'Color','r');
plot(res(1,[1,3]),res(2,[1,3]),'Color','r');
plot(res(1,[2,4]),res(2,[2,4]),'Color','r');
plot(res(1,[6,8]),res(2,[6,8]),'Color','r');
plot(res(1,[5,7]),res(2,[5,7]),'Color','r');
end
结果如下：
补充的特征提取函数，要加在主文件夹下
function f = feature_extract(data) %%f = feature_extract([l,w,h,0;temp])
point_cloud = data(2:end,1:3);
ref = data(2:end,4);
h = data(1,3);
w = data(1,2);
max_x = max(point_cloud(:,1));
min_x = min(point_cloud(:,1));
max_y = max(point_cloud(:,2));
min_y = min(point_cloud(:,2));
f1 = [h];% f1 = [w,h];
slices_num = 10;
if max_x - min_x > max_y - min_y
t = linspace(min_x,max_x,slices_num+1);
flag = 1;
else
t = linspace(min_y,max_y,slices_num+1);
flag = 2;
end
f2 = [];
for i = 1:size(t,2)-1
lb = t(i); ub = t(i+1);
sum_h = 0; num = 0;
for j = 1:size(point_cloud,1)
point = point_cloud(j,:);
if point(flag)<ub && point(flag)>lb
sum_h = sum_h + point(3);
num = num + 1;
end
end
if num == 0
f2 = [f2,0];
else
f2 = [f2,sum_h/num];
end
end
if flag == 1
f3 = (max_y-min_y)/h;
else
f3 = (max_x-min_x)/h;
end
f4 = [mean(ref),std(ref)];
num1 = 0; num2 = 0;
for i = 1:size(ref)
if ref(i)>=0 && ref(i)<0.2
num1 = num1 + 1;
end
if ref(i)>=0.2 && ref(i)<0.4
num2 = num2 + 1;
end
end
f5 = (num1-num2)/size(point_cloud,1);
f = [f1,f2,f3,f4,f5];
end
看到这里点个赞再走吧！！！！！！！！！！！！
编写不易，求个点赞！！！！！！！
“你是谁？”
“一个看帖子的人。”
“看帖子不点赞啊？”
“你点赞吗？”
“当然点了。”
“我也会点。”
“谁会把经验写在帖子里。”
“写在帖子里的那能叫经验贴？”
“上流！”
cheer！！！
1648
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
