Image recognition method based on edge calculation

Abstract

The invention relates to the technical field of computer vision and image recognition, in particular to an image recognition method based on edge computing, which comprises the following steps: dynamically capturing an original image through a plurality of edge nodes, rejecting redundant regions through a multi-modal perception triggering mechanism, and establishing a cooperative processing group. Illumination equalization, noise filtering and resolution self-adaptive compression tasks are distributed according to dynamic role election, a standardized preprocessed image is generated, a lightweight convolutional neural network is operated in parallel to extract a dual-channel feature vector, and after entropy coding lossless compression and equipment identity tag and time sequence stamp attachment, the dual-channel feature vector is transmitted to a cloud end by adopting a lightweight encryption protocol. The cloud end analyzes the data packet, reconstructs a feature topological graph based on space-time relevance, loads a depth residual error recognition model to execute feature fusion and classification decision, feeds back and updates the weight of an edge node model, solves the problems of low collaborative efficiency and feature distortion, and improves the efficiency and precision of image recognition.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer vision and image recognition, in particular to an image recognition method based on edge computing. BACKGROUND

[0002] Computer vision and image recognition is an important technology. Under the background of the popularity of Internet of Things devices, the increasing demand for real-time and privacy protection, this technology is the key support to break through the bottleneck of traditional cloud centralized recognition. It can not only avoid the problem of high bandwidth occupation and increased delay caused by large-scale transmission of raw images to the cloud, meet the demand for real-time recognition of mobile terminals and edge monitoring devices, but also reduce the upload of sensitive images through edge-side data preprocessing, protect user privacy, and adapt to low-power terminal devices by reducing hardware dependence through lightweight models, promote the landing of image recognition technology in various terminal scenarios, and balance recognition accuracy and running efficiency. In actual application, the existing image recognition technology based on edge computing faces the core problems of low efficiency of multi-edge node cooperative processing, feature extraction distortion and asynchronous cross-node data, resulting in low recognition efficiency and insufficient accuracy. In traditional technology, the multi-edge node does not exclude the field of view angle overlap area when capturing images, generates a large amount of redundant data to occupy computing power, and the preprocessing does not dynamically adjust the strategy in combination with the device motion state and environmental light changes. The shallow feature extraction only relies on the local simple model, does not introduce the cloud depth model constraint, and is easy to appear edge texture and local structure feature distortion. Before data transmission, the feature vector is not efficiently lossless compressed, and the device identity and time sequence identifier are not unified, resulting in that after the cross-node data is uploaded to the cloud, it is difficult to accurately analyze due to the time and space asynchronization and dictionary mismatch, and even there is a risk of data leakage due to no encryption. This defect causes the image quality to decrease due to redundant data and improper preprocessing, the feature distortion further reduces the quality of the recognition basic data, and the asynchronous cross-node data makes the cloud unable to effectively fuse the multi-node features, finally makes the recognition process time-consuming and high in misjudgment rate, which cannot meet the scene demand of intelligent security real-time early warning and mobile device instant recognition. At the same time, the transmission of uncompressed data wastes bandwidth, and the transmission without encryption exists the risk of privacy leakage, which cannot guarantee the practicability and security of image recognition. In order to solve this technical problem, we provide an image recognition method based on edge computing. SUMMARY

[0003] The purpose of the present application is to provide an image recognition method based on edge computing to solve the problems raised in the background art.

[0004] To achieve the above purpose, one of the purposes of the present application is to provide an image recognition method based on edge computing, comprising the following steps: S1, multiple edge computing nodes deployed on the terminal equipment side dynamically capture raw images, establish a cooperative processing group through inter-node communication, perform light equalization, noise filtering and resolution adaptive compression on the raw images, and generate standardized preprocessed images; S2, a lightweight convolutional neural network is run in parallel on the edge computing nodes to extract shallow features from the standardized preprocessed images, wherein the first level node extracts edge texture features, the second level node extracts local structure features, and a dual-channel feature vector is generated; S3, the dual-channel feature vector is losslessly compressed by an entropy encoding algorithm, a device identity tag and a time stamp are added to form a multi-node feature data packet, and a lightweight encryption protocol is used to transmit the multi-node feature data packet to a cloud recognition center; S4, the cloud recognition center parses the multi-node feature data packet, reconstructs the feature topology graph based on the spatiotemporal correlation, loads the deep residual recognition model to perform feature fusion and classification decision, and outputs the image recognition result and feeds back to the edge node to update the local model weight.

[0005] Compared with the prior art, the beneficial effects of the present application are: The present application uses a multi-modal perception trigger mechanism to establish a cooperative processing group through multiple edge computing nodes, assigns light equalization, noise filtering and resolution adaptive compression tasks to generate standardized preprocessed images based on a dynamic role election protocol, runs a lightweight convolutional neural network in parallel to extract a dual-channel feature vector, and transmits the dual-channel feature vector to the cloud through a lightweight encryption protocol based on the device identity tag after lossless compression and addition of a layered device identity tag and a fusion time stamp. The cloud recognition center parses the data packet, reconstructs the feature topology graph based on the spatiotemporal correlation, loads the deep residual recognition model to perform feature fusion and classification decision, and then feeds back to the edge node to update the model weight through the dual-channel backpropagation path. The overall technical effect is that multiple edge nodes are efficiently coordinated, image features are accurately extracted, cross-node data is safely synchronized, and the recognition efficiency and accuracy are improved. The problem of low recognition efficiency and insufficient accuracy caused by inefficient multi-edge node cooperative processing, feature extraction distortion and cross-node data asynchronization in image recognition based on edge computing is effectively solved. BRIEF DESCRIPTION OF DRAWINGS

[0006] Figure 1 The system scene for adjusting the image acquisition frequency and cross-node field of view angle overlap analysis for the motion state sensor and the ambient light parameter; Figure 2 The overall workflow diagram of the present application; Figure 3 The principle diagram of mapping the parsed dual-channel feature vector to a three-dimensional spatiotemporal coordinate system. DETAILED DESCRIPTION

[0007] With reference to the drawings of the embodiments of the present application, the technical solutions in the embodiments of the present application will be clearly and completely described, obviously, the described embodiments are only a part of the embodiments of the present application, not all the embodiments. Based on the embodiments of the present application, all other embodiments obtained by those skilled in the art without creative labor are within the scope of protection of the present application.

[0008] Please refer to Figure 2 The embodiment provides an image recognition method based on edge computing, which comprises the following steps: S1, a plurality of edge computing nodes deployed on the terminal device side dynamically capture original images, establish a cooperative processing group through inter-node communication, perform light equalization, noise filtering and resolution adaptive compression on the original images, and generate standardized preprocessed images; S2, a lightweight convolutional neural network is run in parallel on the edge computing node, shallow feature extraction is performed on the standardized preprocessed image, wherein the first level node extracts edge texture features, the second level node extracts local structure features, and a double-channel feature vector is generated; S3, the double-channel feature vector is losslessly compressed by an entropy coding algorithm, a device identity tag and a time stamp are added to form a multi-node feature data packet, and a lightweight encryption protocol is used to transmit the multi-node feature data packet to a cloud recognition center; S4, the cloud recognition center analyzes the multi-node feature data packet, reconstructs the feature topology graph based on the space-time correlation, loads the deep residual recognition model to perform feature fusion and classification decision, outputs the image recognition result and feeds back to the edge node to update the local model weight.

[0009] When the plurality of edge computing nodes deployed on the terminal device side dynamically capture the original images, a multi-modal perception triggering mechanism is used, and the specific steps are as follows: Based on the motion state sensor data and the environmental light intensity parameter of the terminal device, the image acquisition frequency is dynamically adjusted, when the device is continuously stationary and the environmental light is suddenly changed, the high frame rate capture mode is activated, and a cross-node field of view angle overlap analysis algorithm is introduced, the device pose information is exchanged through inter-node communication, the redundant image area synchronously captured by the plurality of edge computing nodes is automatically removed, and a non-overlapping coverage original image set is generated.

[0010] When the cooperative processing group is established through inter-node communication, a dynamic role election protocol is used, and the specific steps are as follows: According to the real-time computing load and the remaining power of each edge computing node, a master node is elected to coordinate the task allocation of light equalization. The light equalization adopts an adaptive gamma correction and Retinex fusion algorithm. According to the ambient light distribution map analyzed by the master node, a correction parameter table is dynamically generated and distributed to all nodes in the collaborative group. Noise filtering combines motion state sensor data to select a filtering strategy. When the device is in motion, a motion blur compensation type three-dimensional filter is enabled. When it is stationary, a non-local mean filter is enabled. The resolution adaptive compression dynamically adjusts the compression ratio based on the last round of recognition confidence feedback from the cloud recognition center. When the confidence is lower than the set threshold, an edge structure preserving wavelet compression is used.

[0011] When running a lightweight convolutional neural network in parallel on edge computing nodes, a model dynamic loading mechanism is adopted. The specific steps are as follows: From the cloud recognition center, obtain the convolution kernel weight subset optimized according to the device type. The shallow feature extraction includes a double-path parallel structure. The first path uses depth separable convolution to extract wide receptive field features. The second path uses a hollow convolution to capture multi-scale details. The outputs of the two paths are weighted and fused through a feature re-labeling module. An online distillation learning mechanism is introduced. The intermediate layer features of the deep residual recognition model issued by the cloud recognition center are used as teacher signals to constrain the shallow feature extraction process of the lightweight convolutional neural network of the edge node.

[0012] When the first-level node extracts edge texture features, a direction-adjustable Gabor filter set and Sobel operator fusion detection is used. The specific steps are as follows: Through direction consistency constraint, false edge response is removed. When the second-level node extracts local structure features, a spatial pyramid pooling layer is constructed. The grid area of the normalized preprocessed image is divided at multiple scales. The joint descriptor of the gradient direction histogram and the local binary pattern is calculated in each grid. Finally, the edge texture feature vector and the local structure feature vector are normalized and spliced to form a double-channel feature vector. The inter-channel correlation reduction operation is performed before the execution of the two channels to eliminate the collinearity interference of the two types of features.

[0013] When the double-channel feature vector is losslessly compressed through an entropy encoding algorithm, the specific steps are as follows: A Huffman coding dictionary is constructed using the spatial sparsity of the feature vector. The dictionary generation rule is as follows: The edge texture feature vector is preprocessed using run-length encoding, and the local structure feature vector is preprocessed using differential pulse code modulation. The encoding dictionary is dynamically generated by the master edge computing node based on the feature statistical characteristics of all nodes in the collaborative processing group and is distributed to the nodes in the group through a lightweight encryption protocol. The compression process adopts a two-stage pipeline architecture. The first stage performs feature vector block encoding, and the second stage performs arithmetic encoding and re-compression on the encoded data stream.

[0014] The specific steps are as follows when the additional equipment identity tag forms a multi-node feature data packet with a time stamp: The equipment identity tag adopts a hierarchical coding structure, including the device physical address, the cooperative processing group number to which the device belongs, and the node role identifier. The time stamp combines an absolute time stamp and a relative frame sequence number in the cooperative processing group. The relative frame sequence number is aligned through the synchronization pulse broadcast by the master node. The data packet encapsulation complies with the lightweight message aggregation specification, merges multiple double-channel feature vectors into a super data packet according to spatial and temporal proximity, and embeds an entropy coding dictionary version check code in the packet header. The lightweight encryption protocol uses a key derivation function based on the equipment identity tag to generate a unique session key for each cooperative processing group.

[0015] The specific steps are as follows when the cloud recognition center analyzes the multi-node feature data packet: First, reconstruct the cooperative processing group logical topology through the group number in the device identity tag, and synchronize the cross-node feature data packet according to the relative frame sequence number in the time stamp; then, use the entropy coding dictionary version check code embedded in the packet header to search the local dictionary library. If the check fails, request a dictionary incremental update from the master edge computing node; during the analysis process, perform feature integrity verification. When missing data is detected, reconstruct the missing data based on the feature vectors of adjacent nodes through spatial and temporal correlation.

[0016] The specific steps are as follows when reconstructing the feature topology graph based on spatial and temporal correlation: Map the analyzed double-channel feature vector to a three-dimensional space-time coordinate system, with the coordinate axes representing the device geographical position, the capture time window, and the feature channel dimension. Build a feature propagation model between nodes through a graph convolution network, where the edge weight is dynamically calculated based on the device distance and time difference. When loading the deep residual recognition model for feature fusion, use attention-guided multi-level residual jump connection. The first jump connection fuses edge texture features, and the second jump connection fuses local structure features. In the classification decision stage, introduce an uncertainty estimation module. When the probability entropy of the output class exceeds a threshold, trigger the resolution adaptive compression ratio improvement mechanism.

[0017] The specific steps are as follows when outputting the image recognition result and feeding it back to the edge node to update the local model weight: Construct a double-channel backpropagation path. The first path directly returns the gradient of the classification decision layer to the feature topology graph modeling module of the cloud recognition center to optimize the graph convolution network parameters. The second path extracts the gradient components related to shallow features in the deep residual recognition model, which are attached to the feedback instructions after quantization and compression. After receiving the feedback instructions, the edge node adjusts the convolution kernel weights of the lightweight convolutional neural network using the sparse gradient update algorithm. During the update process, verify the integrity of the feedback instruction source using the session key, and recalculate the teacher signal constraint based on the online distillation learning mechanism.

[0018] It needs to be further explained that the specific implementation of the multi-modal perception triggering mechanism captures the original image. In the edge computing-based image recognition process, multiple edge computing nodes deployed on the terminal device side need to dynamically capture the original image. To avoid the waste of computing power and redundant data transmission caused by invalid collection, a multi-modal perception triggering mechanism is needed to accurately regulate the collection strategy. The specific implementation is as follows: As shown in Figure 1 First, based on the motion state sensor data of the terminal device and the ambient light intensity parameter, the image acquisition frequency is dynamically adjusted. The motion state sensor data comes from the built-in three-axis acceleration sensor and gyroscope of the device, which real-time collects the acceleration value and angular velocity value of the device. When the acceleration value is less than 0.1 m / s² for 5 seconds continuously and the angular velocity value is less than 0.5 rad / s, it is determined that the device is in a continuous stationary state. When the values exceed the above threshold, it is determined to be in a motion state. The ambient light intensity parameter is collected by the device light sensor, with the unit of lux (lumen). The normal indoor light intensity is about 100-500 lux, and the outdoor strong light can reach more than 10000 lux. The acquisition frequency adjustment logic is as follows: when the device is in motion, to avoid feature loss caused by motion blur, it is set to 10 fps (frames per second); when the device is stationary, it is reduced to 5 fps to save computing power; when it is detected that the device is continuously stationary (more than 10 seconds) and the ambient light intensity changes by more than 200 lux within 1 second (such as from 100 lux to 300 lux, or from 500 lux to 200 lux), the high frame rate capture mode (30 fps) is immediately activated. Because the ambient light mutation can easily cause the image to change dramatically in brightness and detail, high frame rate can capture the image details during the light change process, avoiding the omission of key features. At the same time, a cross-node field of view angle overlap analysis algorithm is introduced to eliminate redundant image areas captured by multiple nodes in synchronization. Each edge computing node exchanges device pose information in real time through a low-power communication protocol. The device pose information includes the physical position coordinates of the node, which are obtained by GPS or indoor positioning system, the camera installation angle and field of view angle parameters. The algorithm determines the overlap range by calculating the intersection area of the field of view angles of different nodes. For example, the field of view angles of node A (position coordinates X1, Y1) and node B (X2, Y2) overlap in the area X3, Y3 to X4, Y4, and the overlap area accounts for 35% of the node A image collection. It is determined that this area is a redundant area, and the system automatically retains the node image that captures this area first and eliminates the overlap of other nodes. Finally, a set of original images covering the target scene without overlap is generated, which ensures the integrity of the scene and avoids repeated calculation of redundant areas in subsequent processing.

[0019] After the non-overlapping capture of the original images is completed, the dynamic role election protocol and the specific implementation of the collaborative preprocessing need to establish a collaborative processing group through inter-node communication to perform standardized preprocessing. In order to avoid task allocation confusion and resource waste, a dynamic role election protocol is used to clearly define the responsibilities of the nodes, and the specific implementation is as follows: First, according to the real-time computing load and the remaining power of each edge computing node, the master node is elected. The real-time computing load is obtained by the resource monitoring module built-in the node, with CPU usage (threshold value is 60%, and the node with lower value is preferred) and memory occupancy (threshold value is 50%) as the core indicators. The remaining power is read by the battery management module, and the node with more than 30% of the remaining power has the qualification of master node election. The election process is broadcast by each node through the communication protocol to broadcast its load and power data. The system automatically calculates the election score (load score = (1-CPU usage) x 0.6 + (1-memory occupancy) x 0.4, power score = remaining power x 0.4). The node with the highest score is elected as the master node, which is responsible for coordinating the light equalization task allocation. The light equalization adopts the adaptive gamma correction and Retinex fusion algorithm: the master node first collects the environmental light intensity data uploaded by all nodes in the collaborative group, combines the light and dark distribution of the image collected by each node, generates an environmental light distribution map, and dynamically generates a correction parameter table based on the distribution map. For the dark area of the image (pixel gray value < 50), the gamma value of the adaptive gamma correction is set to 0.8 (to enhance the brightness of the dark area), and for the bright area (gray value > 200), the gamma value is set to 1.2 (to suppress overexposure). The Retinex fusion algorithm separates the light component and the reflection component of the image, extracts the light layer through multi-scale Gaussian filtering, and retains the detail information in the reflection layer. The corrected gamma image and the Retinex reflection image are fused with a weight of 0.7:0.3 to generate an image with equal light. The master node distributes the above correction parameter table (including the gamma value, filter radius, etc. of each node) to all nodes through group communication to ensure that the preprocessing standards of each node are consistent. The noise filtering strategy dynamically selects based on the motion state sensor data: when the motion state sensor detects that the device is in motion (acceleration value > 0.1 m / s²), the motion blur compensation type three-dimensional filter is enabled. This filter algorithm introduces a time dimension based on traditional two-dimensional space filtering, compensates for pixel blur caused by motion by analyzing the motion trajectory of three consecutive images (such as an object moving from left to right), and filters random noise. When the device is in a stationary state, non-local mean filtering is enabled, which searches for similar pixel blocks in the image (search window 8x8, similar window 3x3) to replace the current pixel value with the mean value of similar blocks, effectively removing Gaussian noise and salt and pepper noise while preserving image edge details. The resolution adaptive compression dynamically adjusts the compression ratio based on the last round of recognition confidence feedback from the cloud recognition center: when the last round of recognition confidence (such as the probability value of target recognition) is higher than 85%, the regular JPEG compression (compression ratio 0.6, quality and volume), when the confidence is lower than 85%, it is determined that the current image details may be insufficient, and an edge structure preserving wavelet compression is used, the image is decomposed into low frequency approximation coefficients and high frequency detail coefficients through wavelet transform, the high frequency coefficients reflecting the edge features are retained, and the low frequency coefficients and non-edge high frequency coefficients are compressed, so that the image volume is reduced, the edge detail loss is avoided, and the key information is reserved for subsequent feature extraction.

[0020] After the specific implementation of the model dynamic loading and the shallow feature extraction cooperates with the group to generate the standardized preprocessed image, the lightweight convolutional neural network needs to be run in parallel on the edge computing node to extract the shallow features. The computing power of different terminal devices is quite different. In order to avoid the processing delay caused by insufficient computing power, the model dynamic loading mechanism is adopted, and the specific implementation is as follows: First, the optimized convolution kernel weight subset according to the device type is obtained from the cloud recognition center: the cloud pre-trains different versions of lightweight convolutional neural network weights according to the hardware parameters of the terminal device, provides small size convolution kernel weights for low computing power devices, and provides slightly larger size convolution kernel weights for medium and high computing power devices; the edge node requests the weight subset matching the device type through the HTTPS protocol, downloads it to the local convolutional neural network, avoids occupying too much memory by full weight, and uses a double-path parallel structure for shallow feature extraction, which takes into account feature coverage and detail capture: the first path uses a depth separable convolution to extract wide receptive field features, the depth separable convolution separates the traditional 3x3 spatial convolution into a 3x3 depth convolution (convolution for each input channel) and a 1x1 point convolution (fusion of channel features), and the number of parameters is only 1 / 9 of that of the traditional convolution (for example, the traditional convolution parameter of 32 input channels and 64 output channels is about 32x64x3x3=18432, and the depth separable convolution is about 32x3x3+32x64x1x1=2432), which can efficiently extract the wide receptive field features of the image (such as the overall outline of the object); the second path uses a dilated convolution to capture multi-scale details, the dilated convolution inserts a hole (with an expansion rate of 2) in the convolution kernel, which expands the effective receptive field of the convolution kernel from 3x3 to 5x5, without increasing the parameters, it can capture more image details (such as the texture of the object surface), and avoid the loss of details caused by the pooling operation, the outputs of the two paths are weighted and fused through a feature re-labeling module: the feature re-labeling module converts the feature maps (such as 64 channels, 32x32 size) output by the double-path into a 1x1x64 feature vector through global average pooling, and generates weight coefficients (values 0-1, reflecting the importance of the channel) for each channel through a sigmoid activation function, for example, the outline feature channel weight of the first path is 0.6, and the detail feature channel weight of the second path is 0.4, the double-path feature maps are weighted and summed channel by channel according to the weight coefficients, to obtain the fused shallow feature map, and an online distillation learning mechanism is introduced to ensure that the shallow features extracted by the edge node are consistent with the cloud deep model: the cloud recognition center takes the intermediate layer features (usually the feature map output by the 5th layer convolution, size 16x16x256) of the deep residual recognition model (such as ResNet-50) as the teacher signal, and sends it to the edge node through a lightweight communication protocol (such as CoAP); the edge node performs feature distillation on the shallow features (such as 16x16x64 feature map output by the 3rd layer) of the local lightweight convolutional neural network and the teacher signal, calculates the mean square error (MSE) between them, and uses the error as a loss term for back propagation, to adjust the convolution kernel weights of the lightweight model, so that the shallow features extracted by the edge node are consistent with the teacher signal in terms of semantics, and avoid feature distortion caused by model lightweight.

[0021] The specific implementation of edge texture and local structure feature extraction and correlation reduction After the lightweight convolutional neural network extracts the shallow feature map in the double path, the first level node focuses on the image edge texture (such as the outline edge of the object, the texture line), and the second level node extracts the local structure (such as the local component layout of the object), to ensure that the two types of features are complementary and have no redundancy. The specific implementation is as follows: First level node extraction edge texture features, using direction adjustable Gabor filter set and Sobel operator fusion detection: direction adjustable Gabor filter set contains 8 different direction Gabor filter, each filter's Gaussian envelope and sinusoidal modulation frequency fixed, only direction dynamic adjustment along with image edge direction, for example, detection horizontal edge, activate 0° direction filter, detection 45° tilt edge (such as roof slope line), activate 45° direction filter, through this direction adaptability to improve the accuracy of edge response, Sobel operator through the calculation of image in x axis (horizontal) and y axis (vertical) direction gradient value, strengthen the gray difference of edge pixel (such as edge x axis gradient value surge), fusion detection, first, Gabor filter output edge response map and Sobel operator output gradient map according to 0.6:0.The edge texture feature vector (128 dimensions) and the local structure feature vector (256 dimensions) are normalized and spliced to form a double-channel feature vector (128+256=384 dimensions). The Pearson correlation coefficient of the edge texture feature and the local structure feature is calculated. If the correlation coefficient is 0.7, it indicates that there is strong collinearity. Orthogonalization processing (such as Gram-Schmidt orthogonalization) is used to project the two types of features into an orthogonal space, so that the correlation coefficient of the processed feature vector is reduced to below 0.3, ensuring that each type of feature can independently reflect the different properties of the image, providing a high-recognizability feature basis for subsequent compression and recognition.

[0022] After generating the dual-channel feature vector, entropy encoding algorithm is needed for lossless compression. The communication bandwidth between the edge node and the cloud recognition center is limited (such as narrowband Internet of Things commonly used in Internet of Things nodes, bandwidth ≤ 1 Mbps). The transmission efficiency of uncompressed feature vectors (such as 384 dimensions, 32-bit floating point per dimension, about 1.5 KB / vector) is low. Therefore, an efficient encoding dictionary is constructed by using the spatial sparsity of the feature vector (most dimensions are close to 0 or repeated). The specific implementation is as follows: Firstly, a Huffman coding dictionary is constructed using the spatial sparsity of the feature vector. Spatial sparsity refers to the fact that more than 60% of the dimension values in the two-channel feature vector are close to 0 (e.g., absolute value < 0.01) or there are consecutive repeated values (e.g., 10 consecutive dimension values are 0.2 in edge texture features). This characteristic can greatly reduce the amount of data through coding. The dictionary generation rules are designed differently according to the feature type. For edge texture feature vectors, first use run-length coding preprocessing to count the length of consecutive identical values (i.e., run-length). For example, if 8 consecutive dimension values are 0.1, encode it as 8, 0.1, rather than storing 0.1 8 times. For local structure feature vectors, use differential pulse code modulation (DPCM) to store the difference between adjacent dimension feature values. For example, if the feature value sequence is 0.3, 0.4, 0.35, 0.32, encode it as 0.3, +0.1, -0.05, -0.03. By storing the difference, the data redundancy is reduced (the absolute value of the difference is usually smaller than the original value). The coding dictionary is dynamically generated by the master edge computing node based on the feature statistical characteristics of all nodes in the collaborative processing group. The master node first collects the feature vector statistical data uploaded by each node in the group (such as the run-length distribution of edge texture features and the difference distribution of local structure features). For example, it is found that the run-length 5 and value 0.1 appear most frequently (accounting for 15%) in edge features, and the difference +0.05 appears most frequently (accounting for 12%) in local structure features. Based on these statistical frequencies, a Huffman coding algorithm is used to assign variable-length binary codes to each run or difference (high-frequency data is assigned short codes, such as 5, 0.1 encoded as 01; low-frequency data is assigned long codes, such as 2, 0.01 encoding is 1011), a Huffman encoding dictionary containing the feature type-coding-original data mapping relationship is generated, and the master node distributes the dictionary to all nodes in the collaborative group through a lightweight encryption protocol (such as AES-128, the key is derived from the device identity tag), ensuring the safety of dictionary transmission and avoiding confusion of dictionaries of different groups. The compression process adopts a two-stage pipeline architecture to improve efficiency: the first stage performs feature vector block encoding, dividing the 384-dimensional double-channel feature vector into 6 data blocks according to 64 dimensions, each data block independently performs run-length encoding or DPCM preprocessing, and then converts it into a binary data stream through the Huffman encoding dictionary; block processing can avoid overall data loss caused by single vector encoding failure, and facilitate parallel computing (each data block is processed by a different thread); the second stage performs arithmetic encoding on the encoded data stream for further compression. Arithmetic encoding dynamically allocates coding intervals based on character occurrence probability (such as 01 with high occurrence probability, allocating a larger interval), merging the discrete binary stream output by the first stage into a continuous bit stream, further reducing coding redundancy (usually 10%-20% further compression), for example, a certain feature vector is 1000 bits after the first stage encoding, and 850 bits after arithmetic encoding, the compression efficiency is significantly improved, while ensuring lossless restoration (the original feature vector can be restored by reversing the process during decoding). The specific implementation of device identity tag and time stamp encapsulation and lightweight encryption is completed after the double-channel feature vector entropy encoding compression, and the device identity and time information need to be attached to form a multi-node feature data packet. To ensure that the cloud can trace the data source, synchronize the cross-node time, and prevent data from being tampered during transmission, a layered identity tag, a time stamp fusion design, and lightweight encryption are used. The specific implementation is as follows: The device identity tag adopts a layered encoding structure, containing three layers of core information to ensure the uniqueness of the identity and the distinguishability of the role: the first layer is the physical address of the device, i.e. the MAC address of the edge node (such as 00:1B:44:11:3A:B7, globally unique, used to locate the specific terminal device); the second layer is the number of the collaborative processing group to which it belongs, dynamically allocated by the master node when the group is established (such as G001G002, used to identify node data of the same collaborative group in the cloud); the third layer is the node role identifier, represented by 1-bit binary (0 represents the master node, 1 represents the slave node, used to distinguish node responsibilities in the cloud, and the master node data is prioritized for analysis), the three layers of information are concatenated in the order of physical address-group number-role identifier, compressed into a string (such as MDA6MUI6NDQ6MTE6M0E6Qjc7RzAwMTsw) using Base64 encoding, and embedded in the data packet header as the device identity tag. The time stamp combines absolute time stamp and relative frame sequence number in the collaborative processing group, taking into account global time synchronization and group frame alignment: the absolute time stamp uses UTC time format (such as 2024-06-10T14:30:25.123Z) is generated by the system clock of the edge node, ensuring time comparability across devices; the relative frame sequence number within the cooperative processing group is used to solve the problem of different node system clock bias, and the master node sends a synchronization pulse (containing the current relative frame sequence number, initially 0, and increasing by 1 for each pulse sent) through intra-group broadcast every 1 second, and the slave node updates its relative frame sequence number after receiving the pulse, for example, when the master node sends the 5th pulse, the relative frame sequence number of all slave nodes is set to 5, ensuring that the 5th frame image timing collected by different nodes within the same group is aligned, and the final format of the timing stamp is absolute timestamp | relative frame sequence number, which is used as the core identifier of the data packet together with the device identity tag, and the data packet encapsulation complies with the lightweight message aggregation specification to reduce the number of transmissions: multiple double-channel feature vectors within the same cooperative processing group and in spatiotemporal proximity are combined into a super data packet, spatiotemporal proximity refers to a time difference of less than 10 seconds (temporal proximity) and a geographical distance of less than 20 meters (spatial proximity) between the corresponding device locations, for example, 9 feature vectors collected by 3 nodes in G001 group from 14:30:25 to 14:30:35 are combined into 1 super data packet, in addition to embedding the device identity tag and timing stamp, the super data packet header also needs to embed the entropy encoding dictionary version check code, which is the CRC32 check value of the Huffman encoding dictionary, used to verify whether the local dictionary and the edge node dictionary are consistent on the cloud to avoid decoding failure due to dictionary version difference, the lightweight encryption protocol uses a key derivation function based on the device identity tag to generate a unique session key for each cooperative processing group: the PBKDF2 is used as the key derivation function, the cooperative processing group number in the device identity tag is used as the password, and the random salt value issued by the cloud is used as the auxiliary input, and a 256-bit session key is generated through 1000 times of hash iteration, the encryption process only encrypts the payload part of the super data packet, and the compressed feature vector data stream is encrypted, and the header information (identity tag, timing stamp, check code) is not encrypted, which ensures data security and facilitates the cloud to quickly parse the basic information of the data packet, avoiding the parsing delay caused by full packet encryption.

[0023] Specific implementation of cloud recognition center to parse multi-node feature data packet After the multi-node feature data packet is transmitted to the cloud recognition center through the wireless network, the first task is to accurately parse the data packet and extract the effective feature vector, the cloud needs to process the topology association, timing synchronization, dictionary matching and data repair of cross-node data to ensure the reliability of subsequent feature fusion and recognition, the specific implementation is as follows: Firstly, the logical topology of the collaborative processing group is reconstructed by the group number in the device identity tag: the cloud locally stores the registration information of all collaborative processing groups (including group number, member node MAC address, node geographical position), when receiving a data packet, the group number is extracted from the device identity tag, the local registration information is retrieved, the physical positions and roles (master / slave node) of all edge nodes in the group are obtained, the logical topology graph (with nodes as vertices and the distance between nodes as edge weight) is constructed, for example, G001 group contains master node A (position X1, Y1) and slave nodes B (X2, Y2), C (X3, Y3), the nodes are connected by line segments in the topology graph, and the distances between nodes (A-B distance 15 meters, A-C distance 20 meters) are marked, which lays a foundation for subsequent space-time correlation analysis, and the cross-node feature data packet is time-synchronized according to the relative frame number in the time sequence stamp: the system clocks of different edge nodes may have deviations, and it is difficult to achieve accurate time sequence alignment only by relying on absolute time stamp.

[0024] The cloud extracts the relative frame number in each data packet timestamp (such as 56), groups all data packets in the same group according to the relative frame number, for example, data packets with a relative frame number of 5 are grouped into frame 5, containing the feature vectors collected by nodes A, B and C in this frame, and then the data packets in each group are further adjusted in sequence by the absolute timestamp, for example, the absolute timestamp of node A in frame 5 is 14:30:25, and the absolute timestamp of node B is 14:30:26, which is adjusted to A first and B second, ensuring that the cross-node feature data is completely synchronized in the time dimension, avoiding feature correlation errors caused by time sequence misalignment, and then using the entropy coding dictionary version check code embedded in the packet header to retrieve the local dictionary library: the cloud maintains a dynamically updated entropy coding dictionary library, which stores the Huffman coding dictionaries of all collaborative processing groups, and each dictionary is associated with a unique CRC32 check code. When parsing, the check code in the packet header is extracted, and the dictionary with the matching check code is retrieved in the local dictionary library. If the check is successful (the dictionary with the same check code is found), the feature vector data stream is decoded using the dictionary, and if the check fails (no matching dictionary is found, which may be due to the edge node updating the dictionary not synchronized to the cloud), the dictionary incremental update request is sent to the master edge computing node of the group. The master node only needs to upload the difference between the local dictionary and the old dictionary in the cloud, rather than the full dictionary, reducing the transmission bandwidth occupation. After the cloud updates the dictionary, it is decoded again. Feature integrity verification needs to be performed during the parsing process to handle data packet loss: the cloud counts the number of data packets that should be received for each frame group (such as frame 5 group should receive 3 data packets from 3 nodes) based on the collaborative processing group logical topology and time synchronization result. If data packet loss is detected (such as only 2 are received), the missing data is reconstructed by interpolating the feature vectors of adjacent nodes based on spatial and temporal correlation, for example, the frame 5 data packet of node B is missing, the cloud extracts the feature vectors of nodes A (frame 5, 15 meters away from B) and C (frame 5, 25 meters away from B), calculates the spatial weights of both (A weight = 25 / (15+25) = 0.625, C weight = 15 / (15+25) = 0.375), and then combines the feature vectors of node B in the previous frame (frame 4) and the next frame (frame 6) (if they exist) according to the spatial weight x current frame feature + time weight x previous and next frame feature to generate a reconstructed vector consistent with the original feature vector dimension (such as 384 dimensions), ensuring the integrity of the feature data and avoiding recognition accuracy degradation caused by data packet loss.

[0025] Specific implementation of feature topology graph reconstruction and deep fusion recognition After the cloud recognition center completes the analysis of multi-node feature data packets, the discrete dual-channel feature vectors need to be organized into structured feature data according to the spatial and temporal correlation to provide high-quality input for the deep residual recognition model, and the subsequent acquisition strategy is optimized through uncertainty estimation. The specific implementation is as follows: For example Figure 3As shown, the parsed two-channel feature vector is first mapped to a three-dimensional space-time coordinate system to realize the spatialization and time-series organization of the features: the three coordinate axes of the three-dimensional coordinate system are defined as the device geographical position, the capture time window, and the feature channel dimension, respectively. The device geographical position axis (X-axis) uses the latitude and longitude coordinates of the node (e.g., north latitude 30.123° is mapped to X=30123, east longitude 120.456° is mapped to X=120456, and combined as X-axis coordinate 30123-120456), the capture time window axis (Y-axis) divides the continuous time into 10-second / window time blocks (e.g., 14:30:25-14:30:35 is mapped to Y=143025), and the feature channel dimension axis (Z-axis) corresponds to the 384 dimensions of the two-channel feature vector (Z=1 to Z=384). Each feature vector is mapped to a data point (X, Y, Z, feature value) in the three-dimensional coordinate system according to its geographical position, time window, and feature dimension, forming a feature point cloud. A graph convolution network (GCN) is used to construct a feature propagation model between nodes to quantify the cross-node feature correlation: the vertices of the graph convolution network are the feature vectors of the edge nodes, and the edge weights are dynamically calculated based on the device distance and time difference. The device distance is calculated based on the node geographical position coordinates (e.g., the distance between nodes A and B is 15 meters, and the larger the distance, the smaller the weight), and the time difference is the difference between the capture times of the feature vectors (e.g., A is 14:30:25 and B is 14:30:27, with a time difference of 2 seconds, and the larger the difference, the smaller the weight). The edge weight = (1 / device distance) x (1 / (1+time difference)), for example, the edge weight between A and B = (1 / 15) x (1 / 3) ≈ 0.022, and the edge weight between A and C (distance 20 meters, time difference 1 second) = (1 / 20) x (1 / 2) = 0.025. The graph convolution network updates the feature vector of each node by aggregating the feature vectors of adjacent nodes (weighted sum according to edge weight), so that the feature contains the correlation information of the surrounding nodes (e.g., node B's feature integrates part of the features of nodes A and C), strengthens the global correlation of the features, and avoids the limitations of single-node features. When loading a deep residual recognition model for feature fusion, a multi-level residual jump connection guided by attention is used: the deep residual model (e.g., ResNet-101) adds an attention mechanism to the traditional residual block to construct a two-level residual jump connection. The first jump connection focuses on edge texture feature fusion: the edge texture feature vector (128 dimensions) output by the graph convolution network is adjusted in dimension by 1x1 convolution and then jump-connected to the 3rd layer residual block of the model to fuse with the intermediate features of that layer. The attention mechanism assigns weights (e.g., 0.5) to the edge texture features to highlight the object contour information. The second jump connection focuses on local structure feature fusion: the local structure feature vector (256 dimensions) is also adjusted by 1x1 convolution and then jump-connected to the 5th layer residual block of the model to fuse with the intermediate features of that layer, with an attention weight of 0.6, the local component information of the reinforced object, two-level jump connection avoids the gradient disappearance problem of traditional convolutional networks, while ensuring that the edge and structural features extracted by the shallow layer can be transmitted to the deep layer to participate in the final feature fusion, and an uncertainty estimation module is introduced in the classification decision stage to dynamically optimize the resolution adaptive compression ratio: uncertainty estimation is realized by calculating the probability entropy of the output class of the model, after the model classifies the input feature vector, the probability value of each class is output (such as cat probability 0.7, dog probability 0.2, and other probability 0.1), the probability entropy is -Σ(probability*ln probability) (such as the entropy value of this example is approximately -0.7ln0.7-0.2ln0.2-0.1ln0.1≈0.8), the preset probability entropy threshold is 0.9, when the probability entropy of the output class exceeds the threshold (such as entropy value 0.95, which means that the model is uncertain about the classification result, which may be due to insufficient image details), the resolution adaptive compression ratio improvement mechanism is triggered immediately, the cloud sends instructions to the main node of the collaborative processing group to increase the resolution compression ratio of the next round of image acquisition from the current 0.6 to 0.9 (the detail coefficient retention ratio of the edge structure preservation type wavelet compression is increased), ensuring that the image collected later retains more detailed features, improving the certainty of model classification, if the entropy value is lower than the threshold (such as 0.7), the current compression ratio is maintained, balancing the recognition accuracy and transmission efficiency.

[0026] Specific implementation of double-channel back propagation and edge model weight update After the cloud recognition center outputs the image recognition result (such as target class: car, confidence 92%), the model optimization information needs to be fed back to the edge node to update the weight of the local lightweight convolutional neural network. In order to ensure the accuracy, safety and consistency with the cloud model, a double-channel back propagation path is constructed, the specific implementation is as follows: First, a double-channel back propagation path is constructed to optimize the model parameters of the cloud and the edge respectively: the first path focuses on the parameter optimization of the cloud feature topology graph modeling module, and the gradient of the deep residual identification model classification decision layer (such as the partial derivative of the classification loss to the graph convolution network output feature) is directly returned to the cloud feature topology graph modeling module (i.e. the graph convolution network), and the edge weight calculation parameters (such as the weight coefficients of the device distance and the time difference) of the graph convolution network are adjusted through the gradient descent algorithm. For example, if the contribution of a certain node to the classification result is low, the edge weight between the node and other nodes is reduced, so that the subsequent feature propagation focuses more on high contribution nodes, and the effectiveness of the feature topology graph is improved.The second path is optimized for the lightweight model of the edge node, and the gradient component related to the shallow feature in the deep residual recognition model is extracted: the shallow layer (such as the 3rd layer) feature of the deep residual model is directly related to the shallow layer feature (edge texture, local structure) extracted by the edge node, and the gradient (such as the gradient value is-0.3) of the layer feature to the classification loss is calculated, the gradient related to the deep layer feature (such as the 10th layer and later) is removed, and only the shallow layer related gradient is reserved. In order to reduce the amount of feedback data, the reserved gradient component is quantized and compressed, 8-bit linear quantization is used (32-bit floating point gradient is mapped to 0-255 integer, such as gradient-0.3 is mapped to 100, 0.2 is mapped to 150), the compressed gradient data amount is only 1 / 4 of the original, and then it is attached to the feedback instruction (the instruction format is node MAC-gradient data-check code), and is transmitted to the corresponding edge node through HTTPS protocol. After receiving the feedback instruction, the edge node adjusts the convolution kernel weight of the lightweight convolutional neural network by using the sparse gradient update algorithm: based on the principle that the larger the gradient absolute value is, the more significant the influence on the model performance is, the gradient absolute value threshold is set to 0.1, and only the convolution kernel weight whose gradient absolute value exceeds the threshold is updated, for example, the gradient absolute value of a certain 3x3 convolution kernel is 0.15 (exceeds the threshold), and the new weight is updated as old weight- learning rate x gradient (the learning rate is set to 0.01, and the new weight is old weight-0.01x0.15); the convolution kernel whose gradient absolute value is less than 0.1 (such as 0.08) is not updated temporarily to reduce the calculation amount and memory occupation. The integrity of the instruction source needs to be verified by using a session key during the updating process: the edge node extracts the check code from the feedback instruction, decrypts the check code by using the locally stored session key (the only key for communication with the cloud), and if the decrypted check code is consistent with the CRC32 check value of the instruction content, it is determined that the instruction source is legal (from the cloud), and the updating is performed; if it is not consistent, the instruction is discarded to avoid malicious instruction tampering of the model weight. After the updating is completed, the teacher signal constraint is recalculated according to the online distillation learning mechanism to ensure the feature consistency between the edge model and the cloud model: the edge node requests the cloud recognition center to issue the latest intermediate layer feature (teacher signal, such as the 5th layer feature map) in the deep residual recognition model, and calculates the distillation loss (mean square error) between the shallow layer feature (such as the 3rd layer feature map) extracted by the updated lightweight model and the teacher signal. If the loss value exceeds the preset threshold (such as 0.05), the convolution kernel weight of the lightweight model is fine-tuned (such as the loss value is taken as an additional loss term to adjust the weight by back propagation), until the distillation loss is lower than the threshold, to ensure that the shallow layer feature extracted by the edge node is consistent with the cloud model in the semantic level, and to avoid feature drift caused by independent updating, so as to provide more accurate shallow layer feature basis for the next round of image recognition.

[0027] The application dynamically captures original images through multiple edge nodes, removes redundant areas through a multi-modal perception trigger mechanism, establishes a cooperative processing group, distributes illumination equalization, noise filtering and resolution adaptive compression tasks according to dynamic role election, generates standardized preprocessed images, extracts double-channel feature vectors in parallel running of a lightweight convolutional neural network, transmits to the cloud after lossless compression through entropy coding, additional equipment identity tags and time stamps, transmits to the cloud using a lightweight encryption protocol, the cloud analyzes the data packet, reconstructs the feature topology graph based on the spatiotemporal correlation, loads the deep residual recognition model to perform feature fusion and classification decision, and feeds back the updated edge node model weight, solving the problems of cooperative inefficiency and feature distortion, and improving the image recognition efficiency and accuracy.

[0028] The above shows and describes the basic principles, main features and advantages of the present application. Those skilled in the art should understand that the present application is not limited to the above-mentioned embodiments, and the above-mentioned embodiments and descriptions in the specification are only preferred examples of the present application and are not intended to limit the present application. Without departing from the spirit and scope of the present application, various changes and improvements can be made to the present application, and these changes and improvements all fall within the scope of the claimed present application. The scope of protection of the present application is defined by the appended claims and their equivalents.

Claims

1. An image recognition method based on edge computing, characterized in that: Includes the following steps: S1. Multiple edge computing nodes deployed on the terminal device side dynamically capture the original image, establish a collaborative processing group through inter-node communication, and perform illumination equalization, noise filtering and resolution adaptive compression on the original image to generate a standardized preprocessed image. S2. Run a lightweight convolutional neural network in parallel on the edge computing nodes to perform shallow feature extraction on the standardized preprocessed image. The first-level node extracts edge texture features, the second-level node extracts local structural features, and generates a dual-channel feature vector. S3. The dual-channel feature vector is losslessly compressed using an entropy coding algorithm, and a device identification tag and time stamp are added to form a multi-node feature data packet, which is then transmitted to the cloud identification center using a lightweight encryption protocol. S4, the cloud-based recognition center parses multi-node feature data packets, reconstructs the feature topology map based on spatiotemporal correlation, loads the deep residual recognition model to perform feature fusion and classification decisions, outputs image recognition results and feeds them back to the edge nodes to update the local model weights.

2. The image recognition method based on edge computing according to claim 1, characterized in that: When multiple edge computing nodes deployed on the terminal device side dynamically capture the original image, a multimodal perception triggering mechanism is adopted, and the specific steps are as follows: The image acquisition frequency is dynamically adjusted based on the motion state sensor data of the terminal device and the ambient light intensity parameters. When the device is detected to be continuously stationary and the ambient light changes abruptly, the high frame rate capture mode is activated. At the same time, a cross-node field of view overlap analysis algorithm is introduced. The device pose information is exchanged through inter-node communication, and redundant image areas captured synchronously by multiple edge computing nodes are automatically eliminated to generate a set of original images without overlapping coverage.

3. The image recognition method based on edge computing according to claim 2, characterized in that: When establishing a collaborative processing group through inter-node communication, a dynamic role election protocol is used, and the specific steps are as follows: Based on the real-time computing load and remaining power of each edge computing node, a master node is elected to coordinate the allocation of illumination equalization tasks. Illumination equalization adopts an adaptive gamma correction and Retinex fusion algorithm. The correction parameter table is dynamically generated based on the ambient light distribution map analyzed by the master node and distributed to all nodes in the collaborative group. Noise filtering combines motion state sensor data to select filtering strategies. When the device is in motion, motion blur compensation type 3D filtering is enabled, and non-local mean filtering is enabled when the device is stationary. Resolution adaptive compression dynamically adjusts the compression ratio based on the confidence of the previous round of recognition fed back by the cloud recognition center. When the confidence is lower than the set threshold, edge structure preservation type wavelet compression is used.

4. The image recognition method based on edge computing according to claim 1, characterized in that: When running the lightweight convolutional neural network in parallel on edge computing nodes, a dynamic model loading mechanism is adopted, and the specific steps are as follows: The cloud-based recognition center obtains a subset of convolutional kernel weights optimized by device type. The shallow feature extraction includes a dual-path parallel structure. The first path uses depthwise separable convolution to extract wide receptive field features, while the second path uses dilated convolution to capture multi-scale details. The outputs of the two paths are weighted and fused through a feature recalibration module. At the same time, an online distillation learning mechanism is introduced, using the intermediate layer features of the deep residual recognition model issued by the cloud-based recognition center as teacher signals to constrain the shallow feature extraction process of the lightweight convolutional neural network at the edge nodes.

5. The image recognition method based on edge computing according to claim 4, characterized in that: When the first-level node extracts edge texture features, it uses a directional adjustable Gabor filter bank and a Sobel operator for fusion detection. The specific steps are as follows: By eliminating false edge responses through directional consistency constraints, when the second-level node extracts local structural features, a spatial pyramid pooling layer is constructed to divide the grid region of the standardized preprocessed image at multiple scales. In each grid, the joint descriptor of the gradient direction histogram and the local binary mode is calculated. Finally, the edge texture feature vector and the local structural feature vector are normalized and concatenated to form a dual-channel feature vector. Before that, the inter-channel correlation reduction operation is performed to eliminate the collinearity interference of the two types of features.

6. The image recognition method based on edge computing according to claim 5, characterized in that: The specific steps for lossless compression of the dual-channel feature vector using the entropy coding algorithm are as follows: Huffman-coded dictionaries are constructed using the spatial sparsity of feature vectors, where the dictionary generation rules are as follows: Run-length encoding is used to preprocess the edge texture feature vectors, and differential pulse coding modulation is used to modulate the local structure feature vectors. The encoding dictionary is dynamically generated by the main edge computing node based on the feature statistics of all nodes in the collaborative processing group, and distributed to the nodes in the group through a lightweight encryption protocol. The compression process adopts a two-stage pipeline architecture. The first stage performs feature vector block encoding, and the second stage performs arithmetic encoding on the encoded data stream for further compression.

7. The image recognition method based on edge computing according to claim 6, characterized in that: When the additional device identity tag and the time stamp form a multi-node feature data packet, the specific steps are as follows: The device identity tag adopts a hierarchical coding structure, which includes the device's physical address, the number of the collaborative processing group to which it belongs, and the node role identifier. The time stamp integrates the absolute timestamp and the relative frame sequence number within the collaborative processing group. The relative frame sequence number is aligned by the synchronization pulse broadcast by the master node. The data packet encapsulation follows the lightweight message aggregation specification, merging multiple dual-channel feature vectors into a super data packet based on spatiotemporal proximity, and embedding an entropy-encoded dictionary version check code in the packet header. The lightweight encryption protocol uses a key derivation function based on the device identity tag to generate a unique session key for each collaborative processing group.

8. The image recognition method based on edge computing according to claim 7, characterized in that: When the cloud-based identification center parses multi-node feature data packets, the specific steps are as follows: First, the logical topology of the collaborative processing group is reconstructed using the group number in the device identity tag. Then, the cross-node feature data packets are synchronized in time based on the relative frame sequence number in the time stamp. Next, the local dictionary is retrieved using the entropy-encoded dictionary version check code embedded in the packet header. If the check fails, the dictionary is requested to be updated incrementally from the main edge computing node. Feature integrity verification is performed during the parsing process. When a data packet is detected to be missing, the missing data is reconstructed based on the feature vectors of adjacent nodes through spatiotemporal correlation interpolation.

9. The image recognition method based on edge computing according to claim 8, characterized in that: The specific steps for reconstructing the feature topology map based on spatiotemporal correlation are as follows: The parsed dual-channel feature vectors are mapped to a three-dimensional spatiotemporal coordinate system, with the coordinate axes representing the device's geographical location, the capture time window, and the feature channel dimension, respectively. A feature propagation model between nodes is constructed using a graph convolutional network, where the edge weights are dynamically calculated based on the device spacing and time difference. When loading the deep residual recognition model to perform feature fusion, attention-guided multi-level residual jump connections are used. The first jump connection fuses edge texture features, and the second jump connection fuses local structural features. An uncertainty estimation module is introduced in the classification decision stage. When the probability entropy of the output category exceeds the threshold, the resolution adaptive compression ratio improvement mechanism is triggered.

10. The image recognition method based on edge computing according to claim 9, characterized in that: When the output image recognition result is fed back to the edge nodes to update the local model weights, the specific steps are as follows: A dual-channel backpropagation path is constructed. The first path directly backpropagates the gradient of the classification decision layer to the feature topology graph modeling module of the cloud recognition center to optimize the graph convolutional network parameters. The second path extracts the gradient components related to shallow features in the deep residual recognition model, quantizes and compresses them, and then appends them to the feedback instructions. After receiving the feedback instructions, the edge nodes use a sparse gradient update algorithm to adjust the convolution kernel weights of the lightweight convolutional neural network. During the update process, the integrity of the instruction source is verified using a session key, and the teacher signal constraints are recalculated based on the online distillation learning mechanism.

Images