Automatic driving vehicle point cloud identification method and system based on laser radar

Abstract

The invention belongs to the technical field of automatic driving vehicle identification, and discloses an automatic driving vehicle point cloud identification method and system based on a laser radar. According to the method, an automatic driving vehicle point cloud recognition model is built, modular dynamic edge convolution based on a feature sensitivity layer number selection strategy is provided in the model, local geometric information is better captured by dynamically learning a local geometric structure, and the extraction capability of geometric feature information is enhanced. In order to prevent the problem of insufficient information extraction caused by layer number simplification of modular dynamic edge convolution, a selective kernel attention mechanism is introduced, a feature fusion mode is adjusted, residual connection is added, more comprehensive statistical information is captured while original information is reserved, and the multi-scale feature capture capability is improved, so that the classification performance of the model is improved. Especially in the face of noise, sparse data and complex object shapes, high classification accuracy can still be kept, and a more accurate environment perception capability is provided for an automatic driving system.

Description

Technical Field

[0001] The present invention belongs to the technical field of laser radar point cloud processing and autonomous driving vehicle identification, and in particular relates to a laser radar-based autonomous driving vehicle point cloud identification method and system. Background Art

[0002] With the rapid development of 3D scanning technology, point cloud data classification plays an important role in a variety of fields, including autonomous driving, robotic navigation, engineering surveying, and environmental perception. However, the discrete and disordered nature of point cloud data makes feature extraction from point cloud data a challenge. Despite the rapid development of deep learning point cloud classification methods, these challenges remain.

[0003] Deep learning for point cloud classification involves multi-view, voxel, and raw point approaches. Multi-view networks generate 2D images through projection, but the choice of viewing angle can lead to omission of key information. While voxelization preserves 3D structure, it suffers from data sparsity and loss of surface detail. The PointNet network pioneered direct processing of point clouds, using symmetric functions to achieve both disorder and invariance in point clouds. It provides new approaches for addressing disorder and rotational invariance in point clouds. While various approaches have focused on extracting local features, they still haven't addressed the problem of modeling neighborhood relationships caused by the irregular distribution of point clouds.

[0004] The graph-based dynamic convolutional neural network method (Dynamic Graph CNN, DGCNN) utilizes its dynamic edge convolution mechanism (EdgeConv) to perform dynamic convolution operations on the graph structure, extracting layer by layer. It can not only capture local details, but also construct global semantic information, and effectively process unordered point cloud data. However, the existing dynamic graph adopts a fixed structure, resulting in bottlenecks in extracting representative local features and multi-scale features. The weight allocation mechanism of the existing channel attention mechanism may not be able to effectively distinguish between important geometric features and noise, resulting in reduced classification accuracy.

[0005] The high dimensionality, sparsity, and disorder of point cloud data in autonomous driving make point cloud processing and analysis a complex task. Traditional point cloud classification methods typically rely on hand-crafted feature extraction and machine learning algorithms. These methods often require large amounts of manually annotated data and are limited in effectiveness when handling complex scenarios. To overcome these challenges, point cloud classification methods based on deep learning have gradually become a research focus. Deep learning networks can dynamically learn feature representations for point cloud data, which not only improves classification accuracy but also can cope with the changes and uncertainties in the complex environments of autonomous driving. Summary of the Invention

[0006] The purpose of the present invention is to propose a point cloud recognition method for autonomous driving vehicles based on lidar. In this method, a deep learning model based on modular dynamic edge convolution MD-EdgeConv and selective kernel attention mechanism SKAttention is constructed to solve the deficiencies of feature extraction and selection in traditional methods, which is conducive to improving the flexibility of feature selection, reducing dependence on irrelevant features, and adaptively selecting more important geometric information, thereby providing the autonomous driving system with more accurate environmental perception capabilities, which is conducive to improving the accurate recognition capabilities of autonomous driving vehicles.

[0007] In order to achieve the above object, the present invention adopts the following technical solutions:

[0008] A method for point cloud recognition of an autonomous driving vehicle based on laser radar comprises the following steps:

[0009] Step 1. Obtain point cloud data collected by the vehicle-mounted lidar, perform data preprocessing, annotation, and format conversion on the point cloud data, and use the format-converted point cloud data as the training dataset;

[0010] Step 2. Build a point cloud recognition model for autonomous vehicles that includes two-stage feature extraction.

[0011] Among them, the feature extraction at each stage is achieved by collaboratively optimizing feature extraction through a modular dynamic edge convolution Md-EdgeConv and a selective kernel attention mechanism SKAttention;

[0012] Md-EdgeConv extracts local features of point clouds by learning local geometric relationships in point clouds;

[0013] Among them, the first stage Md-EdgeConv is used to process the original features of the input point cloud data; the second stage Md-EdgeConv further captures the local geometric relationship based on the feature extraction results of the first stage;

[0014] At each stage, SKAttention captures multi-scale features through convolution kernels of different receptive fields, uses multiple convolution kernels of different sizes to perform convolution operations to obtain feature information of multiple scales, and introduces a dynamic weight allocation mechanism in the feature fusion stage;

[0015] Then, the point cloud classification results are output through point-by-point convolution, maximum pooling operation and fully connected layer.

[0016] Step 3. Train the model built in step 2 based on the training data set obtained in step 1. After training, obtain point cloud data in real time through the vehicle-mounted lidar and input it into the trained model to output the vehicle point cloud recognition results.

[0017] In addition, based on the above-mentioned laser radar-based point cloud recognition method for autonomous driving vehicles, the present invention also proposes a corresponding laser radar-based point cloud recognition system for autonomous driving vehicles, which adopts the following technical solutions:

[0018] A laser radar-based point cloud recognition system for an autonomous driving vehicle includes an on-board laser radar and a computer device; wherein the on-board laser radar collects point cloud data in real time and uploads it to the computer device; the computer device includes a memory and one or more processors; executable code is stored in the memory; when the processor executes the executable code, it is used to implement the steps of the laser radar-based autonomous driving vehicle point cloud recognition method as described above.

[0019] In addition, based on the above-mentioned laser radar-based point cloud recognition method for autonomous driving vehicles, the present invention also proposes a corresponding computer-readable storage medium on which a program is stored; when the program is executed by the processor, it is used to implement the steps of the above-mentioned laser radar-based point cloud recognition method for autonomous driving vehicles.

[0020] The present invention has the following advantages:

[0021] As described above, the present invention describes a method for point cloud recognition of autonomous driving vehicles based on lidar, in which a deep learning model for point cloud recognition of autonomous driving vehicles is built, wherein the deep learning model adopts a method of fusing the Md-EdgeConv module and the SKAttention mechanism. Md-EdgeConv extracts local features of the point cloud by learning the local geometric relationships in the point cloud; while the SKAttention mechanism strengthens the expression of key features by adaptively adjusting the weights of each point. The Md-EdgeConv and SKAttention mechanisms complement each other and jointly improve the feature capture capability of point cloud data, especially when processing sparse and irregular point cloud data, which can effectively overcome the limitations of traditional methods and thus improve classification accuracy. The feature dimensionality reduction process realizes the conversion from local geometric features to global semantic features through channel expansion and adaptive pooling. Fully connected classification, hierarchical dimensionality reduction combined with Dropout, finally outputs category probability.

[0022] Compared with the traditional EdgeConv, the Md-EdgeConv proposed in the present invention can independently calculate each sample to adapt to the deformation of the point cloud. It fully explores the local geometric relationships in the point cloud data, thereby enhancing the network's feature extraction capabilities in a variety of environments. By introducing the SKAttention mechanism, the model will dynamically adjust the weights of each feature, so that the model can pay more attention to the key feature areas in the point cloud data, especially when facing noise, sparse data and complex object shapes, it can still maintain a high classification accuracy. The two are trained jointly to jointly optimize point cloud representation learning, and ultimately achieve more robust classification performance. By accurately classifying the driving area, the perception and decision-making capabilities of the autonomous driving system can be improved, thereby achieving safer, more efficient and intelligent autonomous driving. This goal will promote the adaptability of the point cloud classification model in complex scenarios, enabling it to enhance the recognition capabilities of autonomous driving vehicles. BRIEF DESCRIPTION OF THE DRAWINGS

[0023] Figure 1 Flowchart of a method for point cloud recognition of an autonomous driving vehicle based on laser radar in an embodiment of the present invention;

[0024] Figure 2 This is a flowchart of the point cloud recognition model for an autonomous driving vehicle constructed in an embodiment of the present invention;

[0025] Figure 3 This is a diagram of the network structure of modular dynamic edge convolution built in an embodiment of the present invention;

[0026] Figure 4 This is a network structure diagram of the selective kernel attention mechanism built in an embodiment of the present invention. DETAILED DESCRIPTION

[0027] The present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments:

[0028] Example 1

[0029] This embodiment proposes a point cloud recognition method for autonomous driving vehicles based on lidar. The method first proposes a modular dynamic edge convolution Md-EdgeConv based on a feature sensitivity layer selection strategy. By dynamically learning local geometric structures, it better captures local geometric information and enhances the ability to extract geometric feature information. Secondly, in order to prevent the problem of insufficient information extraction due to the simplification of the number of layers in modular dynamic edge convolution, the method of the present invention introduces a selective kernel attention mechanism SKAttention module and adjusts the feature fusion method, adds residual connections, retains the original information while capturing more comprehensive statistical information, improves the multi-scale feature capture capability, and thus improves the classification performance of the model. In particular, when faced with noise, sparse data, and complex object shapes, it can still maintain a high classification accuracy. Therefore, the method of the present invention can provide the autonomous driving system with more accurate environmental perception capabilities, thereby improving the accurate recognition capabilities of autonomous driving vehicles.

[0030] like Figure 1 As shown, the laser radar-based point cloud recognition method for an autonomous driving vehicle in this embodiment includes the following steps:

[0031] Step 1. Obtain the point cloud data collected by the vehicle-mounted lidar, preprocess, label, and convert the point cloud data, and use the converted point cloud data as the training dataset.

[0032] The raw point cloud data is sourced from a publicly available online point cloud dataset. This dataset is then imported into a deep learning network for training. Data preprocessing includes filtering to remove outliers and segmenting to identify the desired object categories. The point data is then labeled with labels such as vehicles, pedestrians, and indicator lights, starting at 0. For format conversion, Python software is used to convert the raw point cloud data into the HDF5 format.

[0033] Step 2. Build a point cloud recognition model for autonomous driving vehicles that includes two-stage feature extraction.

[0034] like Figure 2 The network structure of the model is shown. The feature extraction at each stage is achieved by co-optimizing feature extraction through a modular dynamic edge convolution Md-EdgeConv and a selective kernel attention mechanism SKAttention.

[0035] Md-EdgeConv extracts local features of point clouds by learning local geometric relationships in point clouds.

[0036] Among them, the first stage Md-EdgeConv is used to process the original features of the input point cloud data; the second stage Md-EdgeConv further captures local geometric relationships based on the feature extraction results of the first stage.

[0037] In each stage, SKAttention captures multi-scale features through convolution kernels with different receptive fields, uses multiple convolution kernels of different sizes to perform convolution operations to obtain feature information of multiple scales, and introduces a dynamic weight allocation mechanism in the feature fusion stage.

[0038] Then, it goes through point-by-point convolution, maximum pooling operation and fully connected layer in sequence to output the point cloud classification result.

[0039] like Figure 2 As shown, the autonomous driving vehicle point cloud recognition model built in this embodiment includes two layers of modular edge convolution Md-EdgeConv, two layers of SKAttention, a feature dimensionality reduction part, and a fully connected classification part.

[0040] Md-EdgeConv is the core operation of the first two layers, and the local geometric features of the point cloud are extracted through Md-EdgeConv.

[0041] In the first stage, Md-EdgeConv processes the raw features of the input point cloud data and extracts 64-dimensional feature information. In the second stage, Md-EdgeConv extracts 128-dimensional local features based on the previous step to further capture local geometric relationships.

[0042] On this basis, SKAttention at each stage separates the input features according to different convolution kernels, fuses the features to generate global features, and then uses the fully connected layer and softmax to calculate the attention weights of each scale, re-weightedly fuse the features of each different scale according to the weights, and finally perform residual connection.

[0043] Subsequently, point-by-point convolution aggregation features generate 1024-dimensional feature information and incorporate more global contextual information. The feature dimensionality reduction process realizes the conversion from local geometric features to global semantic features through channel expansion and adaptive pooling.

[0044] Fully connected classification, hierarchical dimensionality reduction combined with Dropout, and finally output category probability.

[0045] The following is for the attached Figure 2 The network structure of the point cloud recognition model for the autonomous driving vehicle in this embodiment is described in detail.

[0046] The point cloud recognition model for autonomous driving vehicles includes a two-stage feature extraction layer, a 1D convolution layer, a maximum pooling layer, and a fully connected layer; the two-stage feature extraction layer is divided into a first-stage feature extraction layer and a second-stage feature extraction layer.

[0047] The first-stage feature extraction layer includes the first Md-EdgeConv layer, the first pooling layer, and the first SKAttention layer. The second-stage feature extraction layer includes the second Md-EdgeConv layer, the second pooling layer, and the second SKAttention layer.

[0048] The first layer Md-EdgeConv extracts local features, the first layer pooling layer compresses the dimension through pooling operation, and then the first layer SKAttention implements channel dimension screening to enhance key features. Subsequently, the second layer Md-EdgeConv obtains high-order neighborhood relationships, the second layer pooling layer improves the pooling dimension, and the second layer SKAttention implements global context association enhancement.

[0049] The 1D convolution layer outputs high-dimensional feature information point by point through convolution to form a global feature expression; finally, the maximum pooling operation is used to compress the feature dimension in the spatial dimension, and finally the global features are mapped through three layers of fully connected layers to output the classification results.

[0050] Since the number of EdgeConv module layers is simplified and improved to Md-EdgeConv in the embodiment of the present invention, in order to prevent the modified Md-EdgeConv from insufficient information extraction due to the simplified number of layers, SKAttention is introduced. Md-EdgeConv is used to extract local features. SKAttention captures multi-scale features through convolution kernels with different receptive fields, uses multiple convolution kernels of different sizes for convolution operations, obtains feature information at multiple scales, and introduces a dynamic weight allocation mechanism in the feature fusion stage. This module first uses average pooling and maximum pooling operations to capture overall information, uses the GELU activation function to increase feature expression capabilities, and finally uses the Softmax function to normalize the distribution and assign dynamic weights to each channel.

[0051] Specifically, consider 3D point cloud data of the shape [B, N, 3], where B is the batch size, N is the number of points in each point cloud, and 3 represents the coordinates (x, y, z) of each point. This point cloud data is fed into the autonomous vehicle point cloud recognition model and first enters the first Md-EdgeConv layer for feature extraction. The first Md-EdgeConv layer extracts local features using three convolutional layers. The number of input and output channels of each convolutional layer is 6→64, 64→64, and 64→64, respectively. The output of the first Md-EdgeConv layer is [B, N, 64]. The first pooling layer transforms the output dimension to [B, 64, N]. The first layer, SKAttention, then filters and enhances key features along the channel dimension. The second layer, Md-EdgeConv2, then acquires high-order neighborhood relationships. The second layer, Md-EdgeConv, similarly uses three convolutional layers to extract local features. The number of input and output channels in each convolutional layer increases from 64 to 128, 128 to 128, and 128 to 128, respectively. The second pooling layer increases the pooling dimension to [B, 128, N], and the second layer, SKAttention, strengthens global contextual associations. A 1D convolutional layer then adjusts the number of channels, adaptively eliminating spatial dimensions and retaining the global feature vector [B, 1024]. This is then compressed to the classification dimension [B, 256] via a fully connected layer, and finally outputs the category probabilities via the LogSoftmax classification head.

[0052] like Figure 3 The network structure diagram of modular dynamic edge convolution MD-EdgeConv is shown.

[0053] In this embodiment, a modular edge convolution unit Md-EdgeConv is constructed, and the depth and number of channels of the multi-layer perceptron MLP are freely defined by the layers parameter (such as layers = [3, 64, 128] to define two layers of MLP), separating the neighborhood feature differences and the center features. The first-layer MLP focuses on geometric difference modeling to improve the interpretability of local features. Each sample calculates KNN independently to adapt to point cloud deformation. The K nearest neighbor graph construction, feature difference calculation and multi-layer perceptron in the traditional point cloud processing process are integrated into a unified framework. By dynamically learning the local geometric structure, separating the neighborhood feature difference calculation and the center feature retention mechanism, integrating the unified architecture of KNN graph construction, feature difference calculation and multi-layer perceptron, and supporting dynamic adjustment of network depth and channel dimension. The data processed by KNN is dynamically constructed, and the center point feature X is converted into a vector. center and neighborhood feature X neighbor Make a difference to form relative features, and make the center point X center With edge feature X neighbor -X centerAfter splicing, the input is fed into the MLP, and multi-layer 1×1 convolution blocks are used instead of the fully connected layer to reduce the computational complexity. The spliced ​​features are reshaped into a sequence form and multi-layer convolution blocks are used to extract high-order features. The input data is subjected to a one-dimensional sequence maximum pooling operation to improve the ability to extract local information features.

[0054] The present invention uses deep learning-based point cloud processing technology to analyze and process autonomous vehicles, dynamically adjusting the weights of various features. This allows for greater focus on key feature areas in point cloud data, maintaining classification accuracy for vehicle identification, especially in the face of noise, sparse data, and complex object shapes.

[0055] The model uses a two-layer Md-EdgeConv module with the same structure, generating neighborhood features by dynamically constructing a K-nearest neighbor graph. The KNN graph is independently calculated for each sample, and each K-nearest neighbor is calculated in real time based on the point cloud. First, relevant point cloud data is collected, and the K-nearest neighbor index is independently calculated for the input point cloud. Edge features are constructed based on the feature differences between the center point and the neighborhood points. Multi-layer MLP processes the spliced ​​features to extract higher-level features. Finally, a K-dimensional pooling layer aggregates the neighborhood features of each point and updates the point features. When the two layers of modules are stacked, the second layer reuses the same process but with independent parameters, gradually extracting higher-order information from the local information, and ultimately outputting point cloud features with strong representation capabilities.

[0056] Take the structure of the first layer Md-EdgeConv as an example, Figure 3 As shown in Figure 1, the point cloud data in step 1 is input into the modular dynamic edge convolution Md-EdgeConv, and the local geometric features of the point cloud are extracted by Md-EdgeConv.

[0057] This process involves constructing a dynamic graph and efficiently calculating distances through matrix operations. Then, an MLP process processes the concatenated features to extract higher-level features. Finally, a one-dimensional sequence is subjected to maximum pooling to improve local feature extraction.

[0058] The overall process of modular dynamic edge convolution Md-EdgeConv:

[0059] According to the input point cloud data, the K nearest neighbor dynamic construction map of each point is calculated, and the center point X center Click X with your neighbor neighbor Construct edge features by the feature difference of center With edge feature X neighbor -X center After splicing, the data is input into MLP to extract high-order features, aggregate neighbor information through maximum pooling, and update point features.

[0060] Taking the first layer Md-EdgeConv as an example, the specific processing flow is as follows:

[0061] I. Dynamic adjacency graph construction.

[0062] For the input point cloud X∈R B×N×F , whose shape is [B,N,F], calculates the Euclidean distance between each two points. The formula is as follows:

[0063]

[0064] Among them, dist ij Represents the Euclidean distance between point i and point j.

[0065] x i 、x j ∈R F are the feature vectors of point i and point j respectively, B is the batch size, N is the number of points, F is the input feature dimension, k represents the number of neighbors, and x i,k represents the kth eigenvalue of point i, x j,k represents the kth eigenvalue of point j.

[0066] For each point i, select the first K nearest neighbor indexes knn_indexes in ascending order of distance i , the calculation formula is as follows:

[0067] knn_indexes i =argsort(dist_ i )[1:K+1].

[0068] Among them, dist_ i is a vector of distances between point i and all other points. argsort returns indices sorted in ascending order of distance. [1:K+1] excludes itself and takes the first k nearest neighbors. Finally, the dynamic adjacency graph G is obtained:

[0069]

[0070] in, Represents the neighborhood point set of point i, i∈[1:N].

[0071] II.Edge feature splicing;

[0072] For each neighborhood point pair (i, j), calculate the edge feature e ij :

[0073] e ij =x _j -x _i ∈R F .

[0074] where x_i The center point feature is X center , x_ j is the neighborhood point feature, i.e. X neighbor .

[0075] The center point feature x_ i With edge feature e ij Splicing to form joint features h ij :

[0076] h ij =[x_ i ||e ij ]∈R 2F .

[0077] Where || represents the vector concatenation operation.

[0078] III.MLP transformation.

[0079] The concatenated features h ij Reshape into sequence form:

[0080] H in =Reshape(h ij )∈R B×2F×N×K .

[0081] Among them, H in Reshape() is a sequence of operations.

[0082] Features are extracted through multiple layers of convolutional blocks, each of which contains a 1D convolutional layer, batch normalization, and ReLU activation.

[0083] H out =MLP(H in )=ReLU(BN(Conv1d(H in ))).

[0084] Compared with EdgeConv's dynamic construction of KNN graph for edge feature extraction, Md-EdgeConv uses matrix calculation instead of cyclic dynamic construction of KNN graph, which is more adaptable to changes in point cloud distribution and enhances the ability to extract local features of point clouds.

[0085] IV.K-dimensional pooling aggregation;

[0086] For each point i's neighborhood features, we perform maximum pooling along the K nearest neighbor dimensions, aggregating K neighborhood information to retain the most significant features. The formula for performing maximum pooling along the K nearest neighbor dimensions and aggregating K neighborhood information is as follows:

[0087]

[0088] Among them, xi ′ represents the point feature after aggregation, H out is the output feature tensor, H out (i, j) refers to the eigenvalue of the jth neighbor of the i-th point in the tensor. After the output of K-dimensional pooling, the feature dimension is further compressed through 1D convolution, and the output dimension is [B, C, N].

[0089] The SKAttention mechanism was originally an image processing mechanism. The present invention transforms the SKAttention mechanism into a point cloud processing mechanism. The SKAttention mechanism extracts features in parallel through multi-scale convolution and then splices them together. It then performs full connection and pooling to form weights and weighted fusion to achieve multi-scale feature fusion: convolution kernels of different sizes process inputs in parallel and splice them into multi-scale features. Channel descriptors are generated and weights are calculated through the fully connected layer and global pooling. Finally, the weights of features at each scale are dynamically adjusted through weighted summation to optimize the effective receptive field. The present invention designs convolution kernels of different scales in the SKAttention mechanism and uses multiple convolution kernels of different sizes to perform convolution operations to obtain feature information at multiple scales. The two types of pooling information are fused instead of average pooling, and a channel splicing strategy is used to retain global statistical features. The attention weight is calculated through a dynamic compression rate attention mechanism to generate a weight a1, a3, and a5 for each branch, thereby assigning different attention weights to feature maps generated by different convolution kernels. Finally, weighted fusion of features at different scales is performed to achieve adaptive fusion of information at different scales, and a residual connection is introduced. This approach greatly enhances the model's performance when processing complex geometric structures and inputs of different resolutions, thereby improving the overall feature expression capability.

[0090] like Figure 4 This is the network structure diagram of the selective kernel attention mechanism SKAttention.

[0091] In this embodiment, SKAttention adopts a dynamic multi-branch attention mechanism, which adaptively distributes weights through the fusion of double pooling and the attention mechanism of dynamic compression rate to enhance the expression ability of key features.

[0092] Specifically, SKAttention first captures multi-scale features through convolution kernels with different receptive fields, and uses multiple convolution kernels of different sizes to perform convolution operations on the local point cloud features extracted by Md-EdgeConv to obtain feature information at multiple scales.

[0093] Then, the average pooling and maximum pooling double pooling layers are used to perform average pooling and maximum pooling double pooling operations on the features after the input branch convolution operation, and the double pooled features are spliced ​​to obtain the pooling result.

[0094] The pooling result is passed through the fully connected layer to generate intermediate features, and a dynamic weight allocation mechanism is introduced in the feature fusion stage for feature fusion. The residual connection adds the fused features to the local point cloud features extracted by the original Md-EdgeConv to obtain the output.

[0095] The introduction of the SKAttention module can adaptively adjust the importance of channels and strengthen key feature channels.

[0096] The specific processing flow of SKAttention is as follows:

[0097] I. First, multi-branch convolution is performed to capture multi-scale local features, which can enhance the expressiveness of the model; the input to SKAttention is a tensor X whose dimension is [B, C, N].

[0098] Where B represents the batch size, C represents the number of channels, and N represents the number of feature points.

[0099] The input feature X is extracted with multi-scale features through 1×1, 3×3, and 5×5 convolution kernels respectively. The formula is as follows:

[0100] F t =Conv t (X),t∈{1,3,5}.

[0101] II. Double pooling fusion, which utilizes the complementarity of average pooling and maximum pooling to increase model robustness;

[0102] The features after average pooling and maximum pooling are concatenated. The formula is as follows:

[0103] S=[GAP(F t ),GMP(F t )]∈R B×2C .

[0104] Among them, GAP is global average pooling, GMP is global maximum pooling, S is the concatenated feature vector, and R is the real space; GAP(F t ) represents the global average pooling result, GMP(F t ) represents the maximum pooling result.

[0105] III. Calculate attention weights;

[0106] Each branch convolution independently learns attention weights to dynamically assign feature weights to highlight key areas.

[0107] The calculation formula for the fully connected layer compression is as follows:

[0108]

[0109] Among them, Z represents the output vector, FC compress Represents a compressed fully connected layer, d = max(L,C / reduction), reduction is the channel compression ratio, L is the minimum dimension; W t Represents the output of the branch network, that is, the weight of the fully connected layer of the t-th branch; Indicates the tth different branch number.

[0110] For each branch convolution t, calculate the attention weight a t , the formula is as follows:

[0111]

[0112] Among them, a t Represents the normalized attention weight of each branch convolution.

[0113] IV. Weighted feature fusion.

[0114] Each branch feature is weighted and summed up to enhance key information.

[0115] The corresponding branch convolution features are weighted channel by channel. The formula is as follows:

[0116]

[0117] Where ⊙ represents element-wise multiplication.

[0118] V. The channel-weighted features are fused to obtain the fused features V, and then the fused features are added to the local point cloud features X extracted by the original Md-EdgeConv using the residual connection to obtain the output.

[0119] By adding a residual connection after the SKAttention module, the weighted fused feature V is added to the local point cloud feature input X extracted by the original Md-EdgeConv, that is, To alleviate the gradient disappearance, so as to retain the original features.

[0120] Feature dimensionality reduction achieves the conversion from local geometric features to global semantic features through channel expansion and adaptive pooling. The feature dimension is compressed and the number of channels is increased from 128 to 1024 using convolutional blocks.

[0121] Global feature aggregation, aggregates the local features of each point into global features through adaptive pooling.

[0122] Fully connected classification, hierarchical dimensionality reduction combined with dropout, ultimately outputs class probabilities. Hierarchical feature compression gradually reduces feature dimensions, reducing computational effort and preventing overfitting. Class boundaries are learned through fully connected layers, and class probabilities are output.

[0123] Step 3. Train the model built in step 2 based on the training data set obtained in step 1. After training, obtain point cloud data in real time through the vehicle-mounted lidar and input it into the trained model to output the vehicle point cloud recognition results.

[0124] Specifically, this embodiment trains the model built in step 2 based on the training data set obtained in step 1; during the training process, the cross entropy loss function is used for supervised learning, and the Adam optimizer is used for efficient parameter adjustment.

[0125] After the autonomous vehicle point cloud recognition model is trained, it is deployed. The vehicle's onboard LiDAR acquires point cloud data of the target area in real time. This data is then preprocessed and converted to a new format as described in Step 1. The converted data is then fed into the model, which then generates the vehicle's point cloud recognition results.

[0126] The present invention introduces SKAttention into Md-EdgeConv, and the two work together. Md-EdgeConv dynamically constructs a neighborhood through the KNN graph, and uses MLP to learn the feature differences of adjacent points to capture local geometric structures. Its output is the high-level features after each point interacts with its neighborhood. However, relying solely on a fixed neighborhood may ignore multi-scale context, local features may be sensitive to noise, and the difference in neighborhood importance in different regions is not explicitly modeled, resulting in some key features not being fully utilized. SKAttention captures features of different receptive fields through multi-branch convolution (such as 1×1, 3×3, 5×5 kernels), and combines the global information of average pooling and maximum pooling to enhance the model's perception of local details and overall structure. The attention mechanism adaptively assigns weights to different branches, highlights key features (such as edges, textures), suppresses redundant or noisy information, improves the discriminability of features, retains original local features, avoids the attention mechanism from destroying original useful information, and accelerates training convergence. The combination of Md-EdgeConv and SKAttention effectively addresses the sparsity, irregularity, and noise issues of point cloud data through dynamic local feature extraction and adaptive multi-scale fusion. Md-EdgeConv captures details, while SKAttention integrates multi-scale context.

[0127] To verify the effectiveness of the proposed point cloud recognition model, the following specific experiments are presented. To ensure the feasibility and data quality of the research, the present invention first conducts experiments based on an object point cloud dataset. This dataset contains a rich set of 3D object categories, making it suitable for evaluating point cloud classification tasks. Furthermore, to address issues such as sparse and disordered point clouds, the model's adaptability to diverse environments and different perspectives is tested by processing real-world 3D point cloud data, such as pedestrians, trees, and streetlights.

[0128] The network architecture constructed by the present invention constructs the Md-EdgeConv module and the SKAttention module, which aims to automatically extract discriminative and representative local and global features from point cloud data. Among them, the Md-EdgeConv module learns the geometric features of point cloud data by building local relationships between points, and effectively captures the morphological information of objects. The SKAttention mechanism weights local features and selects the most discriminative key features to enhance the model's ability to handle complex and dynamic scenes. The network training process adopts the standard cross-entropy loss function and combines it with the Adam optimizer for efficient parameter optimization. By introducing strategies such as gradient clipping and dynamic learning rate, it ensures that the model can converge in a relatively short time and avoid overfitting.

[0129] To comprehensively assess model performance, we will conduct a multi-dimensional evaluation using multiple metrics, including classification accuracy and precision. Furthermore, to verify the practical application potential of our proposed method, we will compare it with existing point cloud classification methods (such as PointNet and DGCNN). Benchmark experiments will be conducted using an open-source point cloud dataset. This dataset contains a rich set of 3D object categories, making it suitable for evaluating point cloud classification tasks. This data will be fed into the network for training.

[0130] During training, the Adam optimizer was used to optimize model parameters with a weight decay of 0.01. A learning rate scheduler was used, with an initial learning rate of 0.001 and halved every 20 epochs. The batch size was set to 32, and each experimental model was iterated 200 times. L2 regularization and ReLU activation functions were also used, and a Dropout layer was added after the fully connected layers to prevent overfitting of the network model. To analyze the model's classification performance, overall classification accuracy (OA) and mean class accuracy (mAcc) were used to evaluate the model's classification performance. To verify the feasibility of the network approach, after model training, the lidar-captured point cloud data was preprocessed, annotated, and converted to a format suitable for network input. This processed data was then fed into the network for validation, confirming that the model was able to classify different objects through repeated learning. The dataset was constructed as follows: Raw point cloud data was collected by the lidar sensor and stored in pcd format. Each point cloud contains 3D coordinates and other intensity information. Perform filtering operations on the point cloud data to remove noise points. Also separate ground and non-ground points. For missing or occluded point cloud data, use point cloud data to enhance and expand the number of point clouds. Use CloudCompare software to annotate the point clouds of relevant segmented objects, manually annotate objects such as vehicles and trees, and start the label from 0. Finally, use Python software to convert the dataset into HDF5 format to complete the dataset construction. In order to further verify the reliability of the method of the present invention in the point cloud classification task, the present invention will conduct classification experiments on the ModelNet40 dataset. The classification results are compared with the classification algorithm accuracy of some existing methods to evaluate their classification performance and generalization ability. Such as VoxNet, PointNet, PointCNN, So-Net, PointNet++, AGCN, LFT-Net, DGCNN, LDGCNN, and the comparison results are shown in Table 1.

[0131] Table 1 Comparison of classification accuracy between the method of the present invention and the existing method

[0132]

[0133] As shown in Table 1, the voxel-based VoxNet model performs relatively poorly due to the large volume and sparsity of voxelized data, which can lead to loss of surface information. While point-based models directly process point cloud data, some models lack the ability to capture local information, resulting in slightly lower classification accuracy than models like DGCNN that focus on extracting local information. Both LDGCNN and LFT-Net address local feature limitations through improved dynamic graph mechanisms, resulting in improved accuracy. Furthermore, LFT-Net's dynamic attention weights automatically focus on key areas, resulting in a 0.4% improvement in overall classification accuracy compared to the DGCNN model. Therefore, the present invention considers integrating SKAttention, convolving the input feature map with convolution kernels of varying sizes to extract multi-scale features. Through the attention mechanism, these multi-scale features are adaptively selected and fused, effectively capturing features at different scales and improving model performance and efficiency. Compared to the DGCNN model, the present invention achieves a 1.8% improvement in overall accuracy and a 0.7% improvement in average classification accuracy. In general, the overall classification accuracy of the method of the present invention on the point cloud dataset is 93.3%, and the average classification accuracy is 91.4%. Overall, the classification accuracy is significantly better than other point cloud classification algorithms.

[0134] The present invention is based on the idea of ​​the DGCNN model, and on this basis, it improves the dynamic edge convolution, and realizes efficient feature extraction through the enhancement of the image attention mechanism, providing a new algorithm for point cloud classification. By introducing SKAttention and modular Md-EdgeConv, the hierarchical extraction of local geometric features is realized, while retaining the perception advantages of graph convolution, the model's adaptability to local features is enhanced. The effectiveness and superiority of the model in the point cloud classification task were verified by training experiments on point cloud datasets. The experimental results show that the module can significantly improve the performance of the model in feature extraction and classification, and its final performance is better than other models. The present invention improves the feature extraction module to dynamically adjust the weights of each feature, which can pay more attention to the key feature areas in the point cloud data, improve the ability of the point cloud classification task to identify vehicles in autonomous driving, and provide the autonomous driving system with more accurate and robust environmental perception capabilities.

[0135] Example 2

[0136] This embodiment 2 describes a laser radar-based point cloud recognition system for an autonomous driving vehicle, including a vehicle-mounted laser radar and a computer device; wherein the vehicle-mounted laser radar collects point cloud data in real time and uploads it to the computer device; the computer device includes a memory and one or more processors; executable code is stored in the memory; when the processor executes the executable code, it is used to implement the steps of the laser radar-based point cloud recognition method for an autonomous driving vehicle in the above-mentioned embodiment 1.

[0137] In this embodiment, the computer device is any device or apparatus with data processing capability, which will not be described in detail here.

[0138] Example 3

[0139] This embodiment 3 describes a computer-readable storage medium on which a program is stored. When the program is executed by a processor, it is used to implement the steps of the laser radar-based autonomous driving vehicle point cloud recognition method in the above-mentioned embodiment 1.

[0140] The computer-readable storage medium can be an internal storage unit of any device or apparatus with data processing capabilities, such as a hard disk or memory, or an external storage device of any device with data processing capabilities, such as a plug-in hard disk, smart media card (SMC), SD card, flash card, etc. equipped on the device.

[0141] Of course, the above description is only a preferred embodiment of the present invention, and the present invention is not limited to the above-mentioned embodiments. It should be noted that all equivalent substitutions and obvious deformation forms made by any technician familiar with this field under the guidance of this specification fall within the substantive scope of this specification and should be protected by the present invention.

Claims

1. A point cloud recognition method for autonomous driving vehicles based on laser radar, characterized in that: The steps include: Step 1. Obtain point cloud data collected by the vehicle-mounted lidar, perform data preprocessing, annotation, and format conversion on the point cloud data, and use the format-converted point cloud data as the training dataset; Step 2. Build a point cloud recognition model for autonomous vehicles that includes two-stage feature extraction. Among them, the feature extraction at each stage is achieved by collaboratively optimizing feature extraction through a modular dynamic edge convolution Md-EdgeConv and a selective kernel attention mechanism SKAttention; Md-EdgeConv extracts local features of point clouds by learning local geometric relationships in point clouds; Among them, the first stage Md-EdgeConv is used to process the original features of the input point cloud data; the second stage Md-EdgeConv further captures the local geometric relationship based on the feature extraction results of the first stage; At each stage, SKAttention captures multi-scale features through convolution kernels of different receptive fields, uses multiple convolution kernels of different sizes to perform convolution operations to obtain feature information of multiple scales, and introduces a dynamic weight allocation mechanism in the feature fusion stage; Then, the point cloud classification results are output through point-by-point convolution, maximum pooling operation and fully connected layer. Step 3. Train the model built in step 2 based on the training data set obtained in step 1. After training, obtain point cloud data in real time through the vehicle-mounted lidar and input it into the trained model to output the vehicle point cloud recognition results.

2. The laser radar-based point cloud recognition method for autonomous driving vehicles according to claim 1, characterized in that: The autonomous driving vehicle point cloud recognition model includes a two-stage feature extraction layer, a 1D convolution layer, a maximum pooling layer, and a fully connected layer; wherein the two-stage feature extraction layer is divided into a first-stage feature extraction layer and a second-stage feature extraction layer; The first-stage feature extraction layer includes the first Md-EdgeConv layer, the first pooling layer, and the first SKAttention layer. The second-stage feature extraction layer includes the second Md-EdgeConv layer, the second pooling layer, and the second SKAttention layer. The first layer, Md-EdgeConv, extracts local features, which are then compressed by the first pooling layer. The first layer, SKAttention, filters and enhances key features along the channel dimension. The second layer, Md-EdgeConv, obtains high-order neighborhood relationships, and the second layer, SKAttention, enhances the global context. The 1D convolution layer outputs high-dimensional feature information point by point to form a global feature expression; Finally, the maximum pooling operation is used to compress the feature dimension in the spatial dimension, and finally the global features are mapped through three fully connected layers to output the classification results.

3. The laser radar-based point cloud recognition method for autonomous driving vehicles according to claim 2, characterized in that: The first layer Md-EdgeConv and the second layer Md-EdgeConv have the same structure, and calculate the K-nearest neighbor dynamic adjacency graph of each point based on the input point cloud data, and construct edge features through the feature differences between the center point and the neighborhood points; The center point and edge features are concatenated and input into MLP, and multi-layer 1×1 convolution blocks are used instead of fully connected layers; Each convolution block contains a 1D convolution, a batch normalization, and a ReLU activation; Finally, the neighbor information is aggregated through maximum pooling, the neighborhood features of each point are maximum pooled along the K nearest neighbor dimension, and the feature dimension is further compressed through 1D convolution.

4. The method for point cloud recognition of an autonomous driving vehicle based on laser radar according to claim 3, characterized in that: The specific processing flow of Md-EdgeConv is as follows: I. Dynamic adjacency graph construction; For the input point cloud X∈R B×N×F , whose shape is [B,N,F], calculates the Euclidean distance between each two points. The formula is as follows: where dist ij represents the Euclidean distance between point i and point j; x i 、x j ∈R F are the feature vectors of point i and point j respectively, B is the batch size, N is the number of points, F is the input feature dimension, k represents the number of neighbors, and x i,k represents the kth eigenvalue of point i, x j,k represents the kth eigenvalue of point j; For each point i, select the first K nearest neighbor indexes knn_indexes in ascending order of distance i , the calculation formula is as follows: knn_indexes i =argsort(dist_ i )[1:K+1]; dist_ i is a vector of distances between point i and all other points; argsort means returning indices sorted in ascending order of distance, and [1:K+1] means excluding itself and taking the first k nearest neighbors; finally, the dynamic adjacency graph G is obtained; Represents the neighborhood point set of point i, i∈[1:N]; II.Edge feature splicing; For each neighborhood point pair (i, j), calculate the edge feature e ij : e ij =x _j -x _i ∈R F ; where x_ i is the center point feature, x_ j is the neighborhood point feature; The center point feature x_ i With edge feature e ij Splicing to form joint features h ij : h ij =[x_ i ||e ij ]∈R 2F ; Where || represents the vector concatenation operation; III.MLP transformation; The concatenated features h ij Reshape into sequence form: H in =Reshape(h ij )∈R B×2F×N×K ; Among them H in The sequence form of reshaping, Reshape() represents the reshaping operation; Features are extracted through multi-layer convolution blocks, each of which contains a 1D convolution layer, batch normalization, and ReLU activation; A out =MLP(H in )=ReLU(BN(Conv1d(H in ))); Where Conv1d represents 1D convolution operation, BN represents batch normalization, and ReLU represents ReLU activation; IV.K-dimensional pooling aggregation; For each point i’s neighborhood features, perform maximum pooling along the K nearest neighbor dimensions to aggregate K neighborhood information: x i ′ Represents the point features after aggregation, H out is the output feature tensor, H out (i, j) refers to the eigenvalue of the i-th point and the j-th neighbor in the tensor; after the output of K-dimensional pooling, the feature dimension is further compressed through 1D convolution, and the output dimension is [B, C, N].

5. The method for point cloud recognition of an autonomous driving vehicle based on laser radar according to claim 2, characterized in that: The SKAttention first captures multi-scale features through convolution kernels of different receptive fields, and uses multiple convolution kernels of different sizes to perform convolution operations on the local point cloud features extracted by Md-EdgeConv to obtain feature information at multiple scales; Then, the average pooling and maximum pooling double pooling layers are used to perform average pooling and maximum pooling double pooling operations on the features after the branch convolution operation, and the double pooled features are spliced ​​to obtain the pooling result; The pooling result is passed through the fully connected layer to generate intermediate features, and a dynamic weight allocation mechanism is introduced in the feature fusion stage for feature fusion. The residual connection adds the fused features to the local point cloud features extracted by the original Md-EdgeConv to obtain the output.

6. The laser radar-based point cloud recognition method for autonomous driving vehicles according to claim 5, characterized in that: The specific processing flow of SKAttention is as follows: I. First, multi-branch convolution is performed to capture multi-scale local features, which can enhance the expressiveness of the model. The input to SKAttention is a tensor X with a dimension of [B, C, N]. Where B represents the batch size, C represents the number of channels, and N represents the number of feature points; The input feature X is extracted with multi-scale features through 1×1, 3×3, and 5×5 convolution kernels respectively. The formula is as follows: F t =Conv t (X),t∈{1,3,5}; II. Double pooling fusion, which utilizes the complementarity of average pooling and maximum pooling to increase model robustness; The features after average pooling and maximum pooling are concatenated. The formula is as follows: S=[GAP(F t ),GMP(F t )]∈R B×2C ; Among them, GAP is global average pooling, GMP is global maximum pooling, S is the concatenated feature vector, and R is the real space; GAP(F t ) represents the global average pooling result, GMP(F t ) represents the maximum pooling result; III. Calculate attention weights; Each branch convolution independently learns attention weights to dynamically assign feature weights to highlight key areas; The calculation formula for the fully connected layer compression is as follows: Among them, Z represents the output vector, FC compress Represents a compressed fully connected layer, d = max(L,C / reduction), reduction is the channel compression ratio, L is the minimum dimension; W t Represents the output of the branch network, that is, the weight of the fully connected layer of the t-th branch; Indicates the tth different branch number; For each branch convolution t, calculate the attention weight a t , the formula is as follows: Among them, a t Represents the normalized attention weight of each branch convolution; IV. Weighted feature fusion; Each branch feature is weighted and summed according to its weight; the corresponding branch convolution feature is weighted channel by channel, and the formula is as follows: Among them, ⊙ represents element-by-element multiplication; V. The channel-weighted features are fused to obtain the fused features V, and then the fused features are added to the local point cloud features X extracted by the original Md-EdgeConv using the residual connection to obtain the output.

7. The method for point cloud recognition of an autonomous driving vehicle based on laser radar according to claim 1, characterized in that: In step 3, the model built in step 2 is trained based on the training data set obtained in step 1; during the training process, the cross entropy loss function is used for supervised learning, and the Adam optimizer is used for parameter adjustment.

8. The method for point cloud recognition of an autonomous driving vehicle based on laser radar according to claim 1, characterized in that: In step 3, after the autonomous driving vehicle point cloud recognition model is trained, the point cloud data of the target area is first acquired in real time based on the on-board laser radar. The collected point cloud data is then preprocessed and format converted in step 1, and the format-converted point cloud data is input into the model; the model obtains the vehicle point cloud recognition result based on the input point cloud data.

9. A laser radar-based point cloud recognition system for autonomous driving vehicles, comprising a vehicle-mounted laser radar and a computer device; wherein: The vehicle-mounted laser radar collects point cloud data in real time and uploads it to a computer device; the computer device includes a memory and one or more processors; executable code is stored in the memory; it is characterized in that when the processor executes the executable code, it is used to implement the steps of the laser radar-based autonomous driving vehicle point cloud recognition method described in any one of claims 1 to 8.

10. A computer-readable storage medium having a program stored thereon; characterized in that: When the program is executed by a processor, it is used to implement the steps of the laser radar-based autonomous driving vehicle point cloud recognition method described in any one of claims 1 to 8.

Images