A method for detecting urban point cloud changes based on Siamese AKPConvX

Abstract

This invention discloses a method for detecting changes in urban point clouds based on Siamese AKPConvX. It achieves logical debranching of computational operators through a shadow point mechanism, significantly improving GPU parallel utilization in large-scale point cloud processing. Employing kernelless dynamic convolution and position-adaptive differential techniques, it extracts features through an AKPConvX encoder and combines this with a PAD module for feature fusion. This allows the network to dynamically generate convolutional kernels based on the local geometry of the point cloud and automatically correct feature differences based on geometric deviations. This achieves the technical effect of improving feature extraction accuracy in complex scenes and significantly reducing the false alarm rate. It possesses advantages such as strong geometric adaptability, good noise resistance, few parameters, and high hardware computational efficiency.

Description

Technical Field

[0001] This invention belongs to the field of remote sensing image processing and computer vision technology, and relates to deep learning analysis of three-dimensional point cloud data, specifically to a method for detecting changes in urban point clouds based on Siamese AKPConvX. Background Technology

[0002] With the acceleration of urbanization, dynamic monitoring and change detection of the urban environment have become crucial. Traditional remote sensing change detection mainly relies on two-dimensional images, but when dealing with complex urban scenes, it is easily affected by changes in lighting, perspective distortion, and shadows.

[0003] Existing 3D point cloud change detection methods can generally be categorized into three types: The first type is post-classification-based methods, which obtain changes by comparing the results of two independent semantic segmentation phases. While logically simple, these methods heavily rely on the accuracy of single-phase segmentation, leading to severe error accumulation. Any minor errors at the segmentation level will be amplified in the detection results. The second type is pre-classification-based methods, which extract geometric or radiometric differences and classify them through a process of first identifying differences and then qualitatively classifying them. These methods are computationally efficient but are highly susceptible to the accuracy of point cloud registration and noise, easily generating a large number of spurious changes. The third type is end-to-end deep learning-based methods, utilizing architectures such as Siamese networks to directly extract changes from the original point cloud. While learning spatiotemporal features offers the advantage of high automation, it still faces significant technical bottlenecks when dealing with complex urban change detection tasks: First, it lacks geometric perception, as it relies on statically predefined kernel point distributions for feature aggregation, making it difficult to adaptively resolve irregular geometric structures such as building damage edges or dense vegetation; second, it suffers from insufficient noise resistance, as the direct feature difference mechanism lacks robust modeling of registration residuals, making it highly susceptible to spatiotemporal displacement interference, leading to massive false change reports; and third, it suffers from an imbalance between energy efficiency and performance, as standard convolution often comes with severe parameter redundancy and computational overhead in pursuit of high-dimensional representation, making it difficult to meet the dual demands of performance and efficiency for large-scale point cloud processing.

[0004] Therefore, there is an urgent need for a point cloud change detection method that combines dynamic geometric adaptability, registration error robustness, and high energy efficiency. Summary of the Invention

[0005] To address the problems of fixed convolution kernels being unable to adapt to complex geometric structures and high false alarm rates caused by multi-temporal point cloud registration errors in the prior art, this invention proposes a city point cloud change detection method based on Siamese AKPConvX. It employs kernelless dynamic convolution and position-adaptive differential techniques, extracts features through an AKPConvX encoder, and combines them with a PAD module for feature fusion, thereby achieving feature extraction in complex scenes.

[0006] A method for detecting changes in urban point clouds based on Siamese AKPConvX, comprising the following steps:

[0007] Step 1: Obtain point cloud data of a certain geographical area at different times and preprocess it;

[0008] Obtain the first point cloud of the same geographic area at different times. Second phase point cloud .

[0009] The preprocessing of point cloud data involves: extracting sub-point cloud blocks using a cylindrical clipping method, followed by coordinate normalization and denoising. Simultaneously, a column of all-1 vectors is concatenated as a bias term for the first-layer features to enhance the model's ability to extract basic geometric features.

[0010] Step 2: Construct robust neighborhoods for point cloud data based on shadow points;

[0011] Traverse all points in the point cloud data and construct a robust neighborhood based on K-nearest neighbor search: treat each point as a center point. When performing a K-nearest neighbor search, the set of its neighboring points is obtained. If the actual number of neighboring points is less than the preset value K, then shadow points with coordinates set to infinity and features of all zeros are introduced to fill in the K neighboring points.

[0012] Step 3: Construct a dual-stream twin encoder based on an inverted bottleneck structure, process the point cloud data after shadow point completion, and obtain the encoding result.

[0013] The encoder consists of multiple cascaded AKPConvX inverted bottleneck modules. and The data is fed into two encoder branches with shared weights, and the data processing at each level is as follows:

[0014] First, the input channels are expanded by a factor of 4 using 1×1 point convolution. Then, AKPConvX dynamic convolution aggregation is performed on the point cloud data in the expanded high-dimensional feature manifold space. After the aggregation result is normalized by BatchNorm and activated by ReLU, it is finally reduced to the target output dimension using a 1×1 linear layer. The dimensionality reduction result is added to the input features through residual connections to obtain the encoding result of this layer, which is then sent to the PAD module.

[0015] At the same time, the encoding result of this layer is transmitted to the next layer for downsampling, and then the above data processing process is repeated to gradually expand the receptive field so as to take into account both local details and global semantics.

[0016] The specific process of AKPConvX dynamic convolution aggregation is as follows:

[0017] Step 301: Calculate neighborhood points based on relative position encoding and extended geometric feature construction. Relative to the center point relative coordinates Using the ScoreNet scoring network to... Extended geometric features Mapped to normalized combination coefficients ,in .

[0018] Step 302: Establish a depth-separable weight library Each of them It is a depthwise convolution weight vector.

[0019] Step 303: Based on the normalized combination coefficients, dynamically assemble the basic geometric weights for the neighborhood point from the weight library:

[0020]

[0021] in, The first prediction for ScoreNet The combined weights of the basis vectors For the weighted library A predefined basis vector.

[0022] Step 304, center point features Inputting the Kernel Attention module yields semantic modulation coefficients. :

[0023]

[0024] Where σ is the Sigmoid activation function, used to generate gating coefficients between [0,1].

[0025] Step 305: Combine the basic geometric weights, semantic modulation coefficients, and neighborhood features to perform depthwise separable weighted aggregation, enabling the convolution kernel to adapt to local geometry, and calculate the final output features. :

[0026]

[0027] in, ⊙ indicates weighting of feature channels, and ⊙ indicates element-wise multiplication.

[0028] In this process, the zero eigenvalues ​​of the shadow points ensure that they do not contribute to the final aggregation result. For the first layer of the network, the neighborhood features involved in the aggregation... The bias term described in step 1 is already included, thereby enabling It can adaptively capture the underlying geometric offset during calculation.

[0029] Step 4: The PAD module performs position-adaptive differential fusion on the encoding results output from each level of the encoder;

[0030] First, nearest neighbor matching and displacement vector calculation are performed: at each level of the encoder, for sampling points in and their corresponding features ,exist Find the nearest neighbor in the corresponding level point cloud using spatial Euclidean distance. and its characteristics Calculate the geometric displacement vector between the two:

[0031]

[0032] Then the displacement vector Input a lightweight alignment scoring network to predict the geometric alignment confidence at that location. :

[0033]

[0034] in, It is the Sigmoid activation function. To align the scoring network. When geometric displacement A smaller value indicates that the two point clouds are well aligned at that location. When the value approaches 1, historical characteristics are given higher weight; when A larger value indicates a significant geometric deviation. As the value approaches zero, the weight of historical features is automatically reduced.

[0035] Finally, the difference characteristics are calculated using the following weighted difference formula. :

[0036]

[0037] in, It refers to the feature vector of the corresponding point that is closest to the current sampling point in the second period (T1 time) in the historical point cloud obtained by spatial location retrieval, and is used as a reference benchmark for calculating feature differences.

[0038] When the geometric deviation is too large, the module automatically reduces the weight of historical features, thereby suppressing spurious change responses.

[0039] Step 5: Multi-scale progressive decoding and feature fusion to construct a U-Net-style decoder.

[0040] The decoder recovers the point cloud resolution after the encoder downsampling by layer through nearest neighbor upsampling, and uses skip connections to integrate the multi-scale difference features output by the PAD module. It connects to the corresponding layer of the decoder to ensure deep integration of high-level semantic information and low-level detail differences.

[0041] Step 6: Perform point-by-point change classification and loss optimization on the decoder output features to achieve urban point cloud change detection.

[0042] The decoder output features are mapped to the label space through the multilayer perceptron classification head to generate point-by-point category predictions.

[0043] The network is trained end-to-end with supervised instruction using the negative log-likelihood (NLL) loss function, ultimately outputting the change category label for each point. The point loss is calculated using the following formula:

[0044]

[0045] in, For real labels, To predict probabilities.

[0046] The loss value guides the network parameter update through backpropagation, enabling the model to gradually converge to the optimal solution and realize the detection of changes in urban point clouds.

[0047] The advantages of this invention are:

[0048] 1. Kernel-free dynamic convolutional architecture (AKPConvX). It features coupled "geometric spatial location adaptation" and "feature semantic context adaptation" to dynamically assemble convolutional weights. This results in the ability to accurately capture the geometric features of irregular objects in urban environments, and significantly reduces the number of model parameters through the concept of depthwise separable convolution.

[0049] 2. Position Adaptive Differential Module (PAD). This module utilizes soft-weighted historical features based on geometric alignment confidence. This significantly reduces the detection of spurious changes caused by multi-temporal point cloud registration errors, improving the algorithm's robustness on real, non-ideal data.

[0050] 3. Inverted Bottleneck Module Design. This innovative approach features dimensionality increase followed by convolution and then dimensionality reduction during the feature extraction stage. This results in the advantage of performing convolution in a high-dimensional feature space to enhance feature representation while maintaining low computational complexity. Attached Figure Description

[0051] Figure 1 Here is the overall flowchart of the point cloud change detection method;

[0052] Figure 2A schematic diagram of the AKPConvX dynamic convolution operator structure;

[0053] Figure 3 Schematic diagram of the computational logic of the Position Adaptive Differential Module (PAD);

[0054] Figure 4 and Figure 5 These are the actual ground value and the predicted value, respectively. Figure 4 This represents the actual ground value. Figure 5 This is the ground prediction value output by the model of this invention; where gray represents the area of ​​change, red represents newly built buildings, green represents demolished buildings, blue represents newly added vegetation, yellow represents the growth and changes of existing vegetation, magenta represents removed vegetation, and cyan represents changes of movable objects.

[0055] Figure 6 This is a comparison chart of the evaluation metrics of the method of the present invention and the benchmark method on the same dataset, representing an embodiment of the present invention. Detailed Implementation

[0056] This invention employs kernel-point-free dynamic convolution and position-adaptive difference (PAD) techniques. It extracts features through an Adaptive KernelPoint Convolution X (AKPConvX) encoder and combines it with a PAD module for feature fusion. This allows the network to dynamically generate convolution kernels based on the local geometry of the point cloud and automatically correct feature differences based on geometric deviations. This achieves the technical effect of improving feature extraction accuracy in complex scenes and significantly reducing the false alarm rate. It boasts advantages such as strong geometric adaptability, good noise resistance, few parameters, and high hardware computational efficiency. The shadow point mechanism enables logical debranching of computation operators, significantly improving GPU parallel utilization during large-scale point cloud processing.

[0057] This invention provides a point cloud change detection method based on twin position adaptive dynamic graph convolution. This embodiment is implemented using the PyTorch deep learning framework and the Torch-Points3D library.

[0058] Implementation environment and parameters:

[0059] Hardware platform: NVIDIA Tesla V100 GPU (16GB VRAM).

[0060] Software environment: Python 3.8, PyTorch 1.8, CUDA 11.1.

[0061] Optimizer: SGD, momentum 0.98, initial learning rate 0.01.

[0062] like Figure 1 As shown, this method consists of the following steps:

[0063] Step 1: Data Preprocessing and Feature Augmentation

[0064] The collected airborne lidar point cloud data was divided into cylindrical regions with a radius of 50m as input samples. The input tensor dimension is (N, ), where N is the number of points, It contains three-dimensional coordinates (x, y, z) and optional color or intensity information. For the first layer, an additional column of all-1 vectors can be concatenated to introduce a bias term.

[0065] The following is a relevant code snippet:

[0066] Urb3DSimulPair.yaml:

[0067] radius: 50

[0068] Urb3DSimulPairCylinder.py:

[0069] cylinder_sampler = CylinderSampling(self._radius, centre, align_origin=False)

[0070] dataPC0_cyl = cylinder_sampler(dataPC0)

[0071] dataPC1_cyl = cylinder_sampler(dataPC1)

[0072] pair_cylinders=Pair(pos=dataPC0_cyl.pos,pos_target=dataPC1_cyl.pos,y=dataPC1_cyl.y, ...)

[0073] pair_cylinders.normalise()

[0074] The sampling radius is set to 50m in the configuration file Urb3DSimulPair.yaml to ensure that each input sample covers a sufficient spatial range to capture complete variation patterns. In Urb3DSimulPairCylinder.py, a CylinderSampling object is instantiated. This object performs spatial clipping on the original point clouds dataPC0 and dataPC1 based on a preset center point, extracting the sub-point cloud within the cylindrical area. Subsequently, a Pair data structure is constructed, encapsulating the coordinates, labels, and other information of the two point clouds into a unified input format, and the normalise() method is called to perform coordinate normalization.

[0075] siamese_akpconvx.py:

[0076] ones=torch.ones(query_points.shape[0],dtype=torch.float).unsqueeze(-1).to(query_points.device)

[0077] x = torch.cat([ones.to(x.dtype), x], dim=-1) if x is not None elseones

[0078] In siamese_akpconvx.py, a tensor of all 1s, with the same number of query points and dimensions (N,1), is first created. The data type is consistent with the device and input features. This tensor of all 1s is then concatenated with the original feature x along the channel dimension (-1 dimension) using the torch.cat() function. This operation introduces a constant bias term into the first convolutional layer, allowing the network to learn coordinate-independent global offset features in the initial stage.

[0079] Step 2: Neighborhood completion based on shadow points

[0080] To address the issue of missing neighborhoods caused by uneven point cloud sparsity, robust neighborhood construction based on shadow points is implemented. For the center point... and its neighborhood set To achieve robust neighborhood construction: when searching the neighborhood of the center point, if the number of actual neighboring points found is less than the preset value K (K=25, which ensures sufficient coverage of local geometric information without introducing excessive computation), a shadow point completion strategy is adopted. That is, virtual points with coordinates set to infinity and eigenvalues ​​set to all zeros are introduced to complete the neighborhood sequence.

[0081] Because the geometric distance between shadow points is extremely large, ScoreNet automatically reduces their weights to near zero when calculating the combination coefficients. Simultaneously, its zero eigenvalues ​​ensure that they do not interfere with the final result, thus maintaining a fixed tensor dimension, improving parallel efficiency, and suppressing boundary noise. More importantly, this mechanism eliminates conditional branch decisions for different neighborhood sizes during the execution of underlying operators by forcibly aligning the dimensions of all neighborhood tensors to a preset value K. This avoids hardware-level instruction pipeline stalls and significantly enhances the determinism and computational throughput of deep learning frameworks when processing massive urban point cloud data in parallel.

[0082] akpconvx.py:

[0083] s_pts_padded = torch.cat([s_pts, torch.zeros_like(s_pts[:1]) +self.inf], dim=0)

[0084] s_feats_padded = torch.cat([s_feats, torch.zeros_like(s_feats[:1])],dim=0)

[0085] neighbor_feats = s_feats_padded[neighb_inds]

[0086] partial_dense.py:

[0087] shadow_x = torch.full((1,) + x.shape[1:], self.shadow_features_fill).to(x.device)

[0088] shadow_points = torch.full((1,) + pos.shape[1:], self.shadow_points_fill_).to(x.device)

[0089] x = torch.cat([x, shadow_x], dim=0)

[0090] pos = torch.cat([pos, shadow_points], dim=0)

[0091] In akpconvx.py, the padded point cloud s_pts_padded is constructed by appending a virtual point with coordinates of self.inf (infinity) to the end of the support point set s_pts. Simultaneously, the corresponding feature tensor s_feats is generated by concatenating an all-zero vector. When the neighborhood index neighbor_inds references a point beyond the original point cloud, it automatically points to that shadow point. Because the geometric distance of the shadow point is extremely large, the combination coefficients calculated by ScoreNet automatically approach zero due to the distance penalty; and its all-zero eigenvalues ​​ensure that no useful information is introduced during feature aggregation.

[0092] A similar strategy is employed in `partial_dense.py`, using `torch.full()` to create shadow point tensors `shadow_points` (with coordinates filled by `self.shadow_points_fill_`) and shadow feature tensors `shadow_x` (with features filled by `self.shadow_features_fill`) with the same dimensions as the original point cloud. `torch.cat()` appends the shadow data to the end of the actual point cloud `x` and `pos`, forcibly aligning the second dimension of all neighborhood tensors to a preset value of `K`. This forced alignment strategy eliminates the dynamic branching of deep learning frameworks when performing tensor operations on different neighborhood sizes, avoiding GPU instruction pipeline pauses and cache invalidations, and significantly improving hardware utilization and throughput for large-scale parallel computing.

[0093] Step 3: Construct a twin-inverted bottleneck coding architecture

[0094] A two-stream architecture is adopted, with the two branches sharing weights. The encoder contains 5 downsampling levels, each employing an AKPConvX inverted bottleneck module. The specific implementation logic of this module is as follows:

[0095] Step 3.1 Dimension Up: Expand the number of input feature channels by 4 times (expansion=4) through 1×1 point-to-point convolution.

[0096] Step 3.2 Dynamic Convolution (AKPConvX Op): Feature aggregation is performed in the expanded high-dimensional space. The aggregation result is then normalized by BatchNorm and activated by ReLU.

[0097] Step 3.3 Dimensionality reduction: Map the features back to the number of output channels using a 1×1 linear layer and then add residual connections.

[0098] Step 3.4 Downsampling: Use grid sampling to reduce point cloud density and expand the receptive field.

[0099] blocks.py:

[0100] # Expand

[0101] x = self.expand(x)

[0102] #AKPConvX

[0103] x = self.pakpconv(q_pos, data.pos, x, idx_neighbors)

[0104] x = self.activation(self.conv_norm(x))

[0105] # Project

[0106] x = self.project(x)

[0107] # Residual

[0108] output = x + shortcut

[0109] The inverted bottleneck structure implemented in `blocks.py` follows a design philosophy of expansion, aggregation, and compression. First, the `self.expand()` method is called, which encapsulates a 1×1 point convolution operation, expanding the number of input feature channels by an expansion ratio (default 4), providing ample expressive freedom for subsequent high-dimensional feature learning. The expanded features are then input into the `AKPConvX` operator `self.pakpconv()`, which receives the query point coordinates `q_pos`, the support point coordinates `data.pos`, the expanded feature `x`, and the pre-computed neighborhood index `idx_neighbors`, performing position-adaptive dynamic convolution aggregation on the high-dimensional feature manifold. The aggregation result is then normalized by `BatchNorm` (`self.conv_norm()`) and activated by ReLU (`self.activation()`), and the dimensionality is reduced to the target output dimension through a `self.project()` projection layer. Finally, the dimensionality-reduced result is added to the input shortcut via a residual connection.

[0110] Step 4: Multidimensional perception and adaptive dynamic assembly of AKPConvX operators

[0111] like Figure 2 As shown, the specific calculation process is as follows:

[0112] Step 4.1 Relative position encoding: Calculate relative coordinates To enhance geometric perception, extended geometric features are used as input, including relative coordinates (x, y, z) and Euclidean distance. Including normalized coordinates, there are a total of 7 input dimensions. ScoreNet (composed of a multilayer perceptron MLP) maps the 7-dimensional extended geometric features of neighborhood points into combined coefficients. Based on M basis vectors from the deep weight library Calculate the basic geometric weights :

[0113] =

[0114] in, Let m be the m-th predefined basis vector in the weight library. These are the weight coefficients predicted by ScoreNet. In this embodiment, M=8.

[0115] Step 4.2 Semantic Feature Modulation: Modulate the center point features Input the Kernel Attention module to generate channel modulation vectors :

[0116]

[0117] Where σ is the Sigmoid activation function, used to generate gating coefficients between [0,1].

[0118] Step 4.3 Feature Aggregation: Combine geometric weights and semantic modulation to calculate the final output features. :

[0119]

[0120] in, ⊙ indicates the weighting of feature channels (Depthwise operation), and ⊙ indicates element-wise multiplication.

[0121] In this process, the zero eigenvalues ​​of the shadow points ensure that they do not contribute to the final aggregation result. For the first layer of the network, the neighborhood features involved in the aggregation... The bias term described in step 1 is already included, thereby enabling It can adaptively capture the underlying geometric offset during calculation.

[0122] Unlike traditional methods that use fixed convolution kernels, this approach dynamically combines coefficients α to create the most suitable convolution kernel for the current shape, achieving accurate extraction of complex objects.

[0123] akpconvx.py:

[0124] delta_p = delta_p / (delta_p.norm(dim=-1, keepdim=True) + 1e-8)

[0125] scores = self.mlp(delta_p)

[0126] scores = F.softmax(scores, dim=-1)

[0127] In akpconvx.py, the relative position vector delta_p is first L2 normalized by dividing it by its own norm (adding 1). -8 To prevent division by zero, a unit direction vector is obtained, preserving geometric direction information while eliminating the influence of scale differences. The normalized delta_p, along with the Euclidean distance, original coordinates, and other 7-dimensional extended geometric features, is input into self.mlp(), which is the ScoreNet scoring network. This network consists of a multilayer perceptron, mapping the geometric features to an M-dimensional score vector scores, which is then normalized along the last dimension using F.softmax() to ensure that the sum of all combination coefficients is 1, satisfying the probability distribution constraints.

[0128] akpconvx.py:

[0129] scores = self.score_net(delta_p)

[0130] assembled_flat = torch.mm(scores_flat, self.weight_bank.weight_bank)

[0131] assembled_weights = assembled_flat.reshape(M, H, C)

[0132] modulation = self.kernel_attention(center_feats)

[0133] intermediate = (assembled_weights neighbor_feats).sum(dim=1)

[0134] output_feats = intermediate modulation

[0135] The normalized scores output by ScoreNet are multiplied by the deep weight library `self.weight_bank.weight_bank` using `torch.mm()` to achieve a linear combination of basis vectors. This operation multiplies the M-dimensional coefficients corresponding to each neighborhood point with the M×C-dimensional weight library to obtain the flattened assembled weights `assembled_flat`. Then, the `reshape()` operation restores them to a three-dimensional tensor `assembled_weights` of (M, H, C), where M is the number of neighborhood points, H is the number of heads, and C is the number of channels. Simultaneously, the center point features `center_feats` are input into the `self.kernel_attention()` module to generate a channel modulation vector `modulation`, which assigns different semantic importance weights to each feature channel. Finally, `assembled_weights` is multiplied element-wise with the neighborhood features `neighbor_feats`, and the result is summed along the neighborhood dimension to obtain the intermediate result. This intermediate result is then multiplied element-wise with `modulation`, completing a dual adaptive weighting from geometric space to semantic space, balancing parameter efficiency and expressive power, and outputting the final aggregated features `output_feats`.

[0136] Step 5: Position Adaptive Differential Correction

[0137] This is the key step in solving registration errors in this invention. For example... Figure 3 As shown, the specific process is as follows:

[0138] At each level of the encoder, the difference between feature F2 at time T1 and feature F1 at time T0 is calculated using the following formula. :

[0139] Step 5.1 Finding nearest neighbors and calculating displacement: For Each point in ,exist Find the spatial nearest neighbor in the corresponding point cloud. And calculate the geometric displacement vector. .

[0140] Step 5.2. Alignment Confidence Prediction: ... Given a lightweight alignment scoring network (AlignmentScoreNet, composed of multilayer perceptrons), predict the alignment confidence. :

[0141]

[0142] This value When geometric deviation When it is too big, Approaching 0.

[0143] Step 5.3. Weighted difference calculation:

[0144]

[0145] Using this formula, when there is a large registration error between the two point clouds (i.e. When it is relatively large, The weight of the feature is reduced, thereby reducing the interference of historical features on the current feature and effectively suppressing the detection of false changes.

[0146] akpconvx.py:

[0147] delta_pos = pos_2 - pos_1_nearest

[0148] w_align = self.align_net(delta_pos)

[0149] diff_feat = feat_2 - (feat_1_nearest w_align)

[0150] In akpconvx.py, the geometric displacement vector between the sampling point at time T1 and the nearest neighbor at time T0 is obtained by calculating delta_pos = pos_2 - pos_1_nearest. This vector is input into the lightweight alignment scoring network self.align_net(), which internally uses a multilayer perceptron to nonlinearly model the magnitude and direction of the displacement to predict the alignment confidence w_align. Then, the weighted difference formula diff_feat = feat_2 - (feat_1_nearest) is used. w_align) calculates feature differences.

[0151] siamese_akpconvx.py:

[0152] nn_list = knn(data0.pos, data1.pos, 1, data0.batch, data1.batch)

[0153] feat_1_nearest = data0.x[nn_list[1, :], :]

[0154] pos_1_nearest = data0.pos[nn_list[1, :], :]

[0155] diff.x = self.pa_diff_modules[scale_idx](data1.x, feat_1_nearest,data1.pos, pos_1_nearest)

[0156] In siamese_akpconvx.py, the knn() function is called to retrieve the nearest neighbor index nn_list for each point in the T1 point cloud data1.pos from the T0 point cloud data0.pos. Based on the index, the corresponding historical features feat_1_nearest and coordinates pos_1_nearest are extracted and passed to the predefined position adaptive differencing module self.pa_diff_modulesscale_idx. This module encapsulates complete alignment confidence prediction and weighted differencing logic, and the output difference feature diff.x retains the true change signal while effectively suppressing spurious change responses caused by registration errors.

[0157] Step 6: U-Net progressive decoding and multi-scale fusion

[0158] The decoder uses nearest-neighbor upsampling to recover the point cloud resolution. Each layer of the decoder receives the upsampled features from the previous layer and compares them with the features calculated by the encoder at the corresponding layer. Perform splicing. Due to different levels Each layer carries fine details and global semantics respectively. This cascading ensures that the model has a strong ability to capture both large-scale new features and subtle edge movements.

[0159] siamese_akpconvx.py:

[0160] diff = self._compute_difference(data0, data1, i)

[0161] stack_down.append(diff)

[0162] for i in range(len(self.up_modules)):

[0163] data=self.up_modules[i]((data, stack_down.pop()), precomputed=self.upsample_target)

[0164] During the encoding phase of siamese_akpconvx.py, the difference features (diff) between the two point clouds are calculated at each downsampling level i by calling the self._compute_difference() method and pushed onto the stack stack_down. This stack stores multi-scale difference information in coarse-to-fine order. During the decoding phase, the upsampling modules self.up_modules are iterated through, and the difference features of the corresponding level are popped from the stack stack_down.pop() in each iteration. These are then packaged with the upsampling result data from the previous layer as a tuple and input into the decoder. Internally, the decoder restores the point cloud resolution through nearest neighbor interpolation or deconvolution operations and concatenates the upsampling features and difference features along the channel dimension.

[0165] Step 7. Model Training and Performance Validation

[0166] The SGD optimizer (momentum 0.98, initial learning rate 0.01) was used for training. To address the class imbalance problem where the majority of points in the point cloud remain unchanged, weighted random sampling was employed. The point loss calculation formula is as follows:

[0167]

[0168] siamese_akpconvx.py:

[0169] self.output = self.FC_layer(self.last_feature)

[0170] In siamese_akpconvx.py, the final feature output by the decoder, self.last_feature, is mapped to the label space through a fully connected layer, self.FC_layer(), generating pointwise class predictions (logits) stored in self.output. The output tensor has dimensions (N, C), where N is the number of points and C is the number of classes (including unchanged classes and various change types).

[0171] siamese_akpconvx.py:

[0172] self.loss_cd=F.nll_loss(self.output,self.labels,weight=self._weight_classes,ignore_index=self._ignore_label)

[0173] During the training phase, the negative log-likelihood loss function F.nll_loss() is used for supervised optimization of the network. The predicted output `self.output`, the ground truth labels `self.labels`, and the class weights `self._weight_classes` are passed in when calculating the loss. The class weights are obtained by taking the inverse of the frequency of each class in the training set, which helps alleviate the class imbalance problem caused by the majority of unchanged points in the point cloud, ensuring that the model can learn sufficient discriminative ability for rare change types. Simultaneously, `ignore_index=self._ignore_label` is set to automatically ignore points labeled as invalid when calculating the loss, avoiding interference from noisy labels on gradient updates. The final loss value `self.loss_cd` guides the network parameter updates through backpropagation, allowing the model to gradually converge to the optimal solution and achieve high-precision urban point cloud change detection.

[0174] When the method of this invention is applied to the prediction of a certain ground area, the comparison between the predicted value and the actual value is as follows: Figure 4 and Figure 5 As shown, by comparison, the present invention achieves the following characteristics:

[0175] 1. It has extremely high classification accuracy:

[0176] Visually, the predicted results are highly consistent with the actual ground values. Particularly in the two most critical urban change categories, red and green, the model accurately reconstructs the spatial location and geometry of buildings. This demonstrates that the AKPConvX dynamic convolution operator can effectively capture irregular man-made structures in cities, overcoming the limitations of traditional fixed convolution kernels in extracting geometric features.

[0177] 2. Excellent noise immunity and robustness:

[0178] Within the vast gray area, the prediction results are remarkably clean, with virtually no color noise. This indicates that the model rarely misinterprets registration errors or sensor noise as changes. This is attributed to the position-adaptive differencing module introduced in this invention, which successfully utilizes alignment confidence to suppress spurious changes caused by registration errors, significantly reducing the false alarm rate.

[0179] 3. Ability to capture details:

[0180] Even for subtle changes scattered throughout the scene, such as newly added blue vegetation points and cyan moving objects, the predicted map corresponds well to the ground truth map. This indicates that the model is not only sensitive to large-scale architectural changes but also possesses good perception capabilities for small-scale environmental subtle changes.

[0181] The results indicate that:

[0182] To verify the effectiveness of the proposed urban point cloud change detection method based on Siamese KPConvX, a comparative experiment was conducted between the proposed method and existing mainstream methods based on fixed kernel points in the same hardware and software environment and dataset. The existing mainstream methods based on fixed kernel points in Siamese KPConv were used as the baseline method.

[0183] Figure 6 The paper presents a comparison of the quantitative evaluation metrics of the method of this invention and the benchmark method on the Urb3DCD-V2 LiDAR dataset, such as... Figure 6 As shown, by comparing the two sets of experimental data, the following conclusions can be drawn, which fully demonstrate the technical superiority of the present invention:

[0184] Significantly Improved Change Detection Accuracy: As shown in the table, the method of this invention achieves 80.24% in the most critical evaluation metric, the average intersection-union ratio (Val mIoU_ch) for change classes, an improvement of 5.31 percentage points compared to the baseline of 74.93%. This advantage is mainly attributed to the AKPConvX dynamic convolution operator used in this invention. Traditional KPConv relies on kernel points at fixed locations, making it difficult to adapt to irregular geometric structures such as building edges and vegetation in urban environments. In contrast, this invention dynamically generates convolution weights based on the local geometric distribution of the point cloud using ScoreNet, enabling more accurate capture of subtle geometric change features, thereby significantly improving the recognition accuracy of changed regions.

[0185] Reduced false positive rate and enhanced robustness: This invention achieves 93.48% average class accuracy (Val mAcc) and 96.26% overall accuracy (ValAcc), both significantly outperforming benchmark methods. This improved accuracy directly reflects the effectiveness of the Position Adaptive Difference (PAD) module in this invention. In the Siamese KPConv method, registration errors in multi-temporal point clouds easily lead to feature misalignment, resulting in numerous spurious changes. The PAD module of this invention, by predicting geometric confidence, automatically weights and suppresses regions with large registration deviations when calculating feature differences, effectively eliminating noise interference caused by registration errors and thus improving overall classification accuracy.

[0186] Superior Model Convergence: Regarding the loss function, the minimum validation loss (Min Val Loss) of this invention is only 0.1347, far lower than the baseline of 0.3123. The lower loss value indicates that the model converges faster and achieves a better fit during training. This is thanks to the shadow point completion mechanism introduced in the AKPConvX operator. This mechanism ensures the stability of tensor calculations by introducing virtual points when there are insufficient neighborhood points, eliminating the interference of boundary noise on gradient descent, and making network optimization more efficient.

[0187] In summary, this invention overcomes the limitations of existing KPConv methods in extracting complex geometric structures and handling registration errors by introducing kernel-free dynamic convolution and position-adaptive differencing techniques. Experimental data show that this method achieves substantial progress in all core metrics, providing a more accurate and noise-resistant solution for urban point cloud change detection.

Claims

1. A method for detecting changes in urban point clouds based on Siamese AKPConvX, characterized in that, The steps are as follows: Step 1: Obtain two sets of point cloud data for a certain geographical area at different times, preprocess them, and construct a robust neighborhood based on shadow points; Step 2: Construct a dual-stream twin encoder based on an inverted bottleneck structure to process the point cloud data after shadow point completion and obtain the encoding result; The encoder consists of multiple cascaded AKPConvX inverted bottleneck modules. It inputs two sets of point cloud data into two encoder branches with shared weights for data processing, obtains the encoding result, and sends it to the PAD module. Step 3: The PAD module performs position-adaptive differential fusion on the encoding results output from each level of the encoder; First, at each level of the encoder, nearest neighbor matching is performed on each sampling point in the two sets of point cloud data, and the displacement vector between the nearest neighbor points is calculated. Then, the displacement vector is input into the alignment scoring network to predict the geometric alignment confidence at that location. ; Finally, the weighted difference formula is used to calculate the difference features between nearest neighbors. ; Step 4: Multi-scale progressive decoding and feature fusion to construct a U-Net-style decoder; The decoder recovers the point cloud resolution after the encoder downsampling by layer through nearest neighbor upsampling, and uses skip connections to integrate the multi-scale difference features output by the PAD module. It connects to the corresponding layer of the decoder to ensure deep integration of high-level semantic information and low-level detail differences; Step 5: Perform point-by-point change classification and loss optimization on the decoder output features to achieve urban point cloud change detection.

2. The urban point cloud change detection method based on Siamese AKPConvX according to claim 1, characterized in that, The preprocessing of point cloud data is as follows: sub-point cloud blocks are extracted using a cylindrical clipping method, and coordinate normalization and noise reduction are performed; at the same time, a column of all-1 vectors is concatenated as a bias term for the first layer features to enhance the model's ability to extract basic geometric features.

3. The urban point cloud change detection method based on Siamese AKPConvX according to claim 1, characterized in that, To construct a robust neighborhood based on shadow points for point cloud data, specifically: Iterate through all points in the point cloud data, using each point as the center point. When performing a K-nearest neighbor search, the set of its neighboring points is obtained. If the actual number of neighboring points is less than the preset value K, then shadow points with coordinates set to infinity and features of all zeros are introduced to fill in the K neighboring points.

4. The urban point cloud change detection method based on Siamese AKPConvX according to claim 1, characterized in that, The specific process of each level of the dual-stream twin encoder processing the two sets of point cloud data is as follows: First, the input channels are expanded by a factor of 4 using 1×1 point convolution. Then, AKPConvX dynamic convolution aggregation is performed on the point cloud data in the expanded high-dimensional feature manifold space. After the aggregation result is normalized by BatchNorm and activated by ReLU, it is finally reduced to the target output dimension using a 1×1 linear layer. The dimensionality reduction result is added to the input features through residual connections to obtain the encoding result of this layer, which is then sent to the PAD module. At the same time, the encoding result of this layer is transmitted to the next layer for downsampling, and then the above data processing process is repeated.

5. The urban point cloud change detection method based on Siamese AKPConvX according to claim 4, characterized in that, The specific process of AKPConvX dynamic convolution aggregation is as follows: Step 301: Calculate neighborhood points based on relative position encoding and extended geometric feature construction. Relative to the center point relative coordinates Using the ScoreNet scoring network to Extended geometric features Mapped to normalized combination coefficients ,in ; Step 302: Establish a depth-separable weight library Each of them It is a depthwise convolution weight vector; Step 303: Based on the normalized combination coefficients, dynamically assemble the basic geometric weights for the neighborhood point from the weight library: ， Step 304, center point features Inputting the Kernel Attention module yields semantic modulation coefficients. : ， Where σ is the Sigmoid activation function, used to generate gating coefficients between [0,1]; Step 305: Combine the basic geometric weights, semantic modulation coefficients, and neighborhood features to perform depthwise separable weighted aggregation, enabling the convolution kernel to adapt to local geometry, and calculate the final output features. : ， in, ⊙ indicates weighting of feature channels; ⊙ indicates element-wise multiplication. In this process, the zero eigenvalues ​​of the shadow points ensure that they do not contribute to the final aggregation result.

6. The urban point cloud change detection method based on Siamese AKPConvX according to claim 1, characterized in that, Dissimilarity characteristics between nearest neighbors : ， and These are the features of the two nearest neighbors.

7. The urban point cloud change detection method based on Siamese AKPConvX according to claim 1, characterized in that, The process of point-by-point change classification and loss optimization is as follows: The decoder output features are mapped to the label space through the multilayer perceptron classification head to generate point-by-point category predictions. The network is trained under end-to-end supervision using the negative log-likelihood (NLL) loss function, and the final output is the change category label of each point. The formula for calculating point loss is: ， in, For real labels, To predict probabilities; The loss value guides the network parameter update through backpropagation, enabling the model to gradually converge to the optimal solution and realize the detection of changes in urban point clouds.

Images