Incremental updating method and device of edge device, equipment and medium

Abstract

The invention relates to the technical field of edge computing, and discloses an incremental updating method for edge equipment, which comprises the following steps: constructing a communication network according to a network access request of the edge equipment; inputting the newly added task into a layered adapter of the edge device, and outputting a gradient difference; the gradient difference is converted into encryption gradient fragments through an encryption algorithm, and the encryption gradient fragments are sent to neighbor equipment in the communication network through a security tunnel; performing an encryption operation on each encryption gradient fragment through an addition homomorphic encryption algorithm to generate a ciphertext gradient fragment, and performing a ciphertext aggregation operation and a random blinding operation on the ciphertext gradient fragment to generate a global gradient; and decrypting the global gradient to generate a plaintext gradient sum, and executing an incremental updating operation on the layered adapter according to the plaintext gradient sum. According to the invention, the plurality of edge devices generate the gradient difference of the adapter through the local data, exchange the encrypted gradient fragments through the communication network, update the local adapter, and improve the communication efficiency and update performance.

Description

Technical Field

[0001] This invention relates to the field of edge computing technology, and in particular to an incremental update method, apparatus, device, and storage medium for edge devices. Background Technology

[0002] Traditional federated learning faces multi-dimensional technical challenges in practical applications. These challenges not only concern data privacy and security but also significantly constrain communication efficiency, model adaptability, and compatibility with edge devices. First, regarding privacy protection, its reliance on a central server architecture has critical vulnerabilities. Even with the distributed training mode of federated learning, the central server still has the potential to infer the original data from aggregated gradients and other information. This directly means that the risk of privacy leakage for the data owner cannot be completely eliminated.

[0003] Secondly, regarding communication overhead and model transmission, adopting a full model transmission update method would generate extremely high communication traffic, especially in scenarios with a large number of participating nodes or limited network bandwidth. This would severely slow down training and deployment efficiency, making it difficult to meet real-time requirements. Simultaneously, the heterogeneity of devices further exacerbates the model adaptation challenge: due to significant differences in computing power and data distribution (such as data volume, data type, and label distribution) among different participating devices, the traditional federated learning strategy of unified global model training is prone to the "edge heterogeneity dilemma," meaning the global model cannot effectively adapt to all devices, leading to a significant drop in model performance on some edge devices, or even the failure of the entire model training.

[0004] Furthermore, the incremental update mechanism for edge devices has significant drawbacks. On the one hand, traditional model fine-tuning methods are prone to "catastrophic forgetting" of previously learned knowledge when introducing new knowledge. According to relevant data, the accuracy of old knowledge can drop by more than 40%, severely impacting the long-term usability of the model. On the other hand, common OTA (Over-The-Air) update methods face security threats, being vulnerable to man-in-the-middle attacks during transmission, leading to tampering of the update package and subsequent device malfunctions or security risks. More importantly, many embedded edge devices are limited by hardware, with memory space often less than 1MB, which is insufficient to support the storage resources required for a full model update, making traditional model update solutions completely infeasible on such devices. Summary of the Invention

[0005] The main objective of this invention is to provide an incremental update method, apparatus, device, and storage medium for edge devices, aiming to solve the problems of privacy leakage, high communication overhead, and catastrophic forgetting and security vulnerabilities in existing federated learning methods for edge incremental updates.

[0006] To achieve the above objectives, the present invention provides an incremental update method for edge devices, comprising: Build a communication network and secure tunnel based on the network access requests sent by edge devices; The system acquires a new task and inputs the new task into a pre-configured hierarchical adapter of the edge device for training, outputting the gradient difference. The gradient difference is converted into encrypted gradient fragments using an encryption algorithm, and these encrypted gradient fragments are then sent by the edge device to neighboring devices in the communication network through a secure tunnel. Each encryption gradient fragment is encrypted using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments. Then, ciphertext aggregation and randomization operations are performed on the ciphertext gradient fragments to generate a global gradient. The global gradient is decrypted to generate a plaintext gradient sum, and an incremental update operation is performed on the hierarchical adapter based on the plaintext gradient sum.

[0007] Furthermore, to achieve the above objectives, the present invention provides an incremental update apparatus for an edge device, comprising: The network construction module is used to build communication networks and secure tunnels based on network access requests sent by edge devices. The gradient difference module is used to acquire new tasks, input the new tasks into the pre-configured hierarchical adapter of the edge device for training, and output the gradient difference. The gradient fragmentation module is used to convert the gradient difference into encrypted gradient fragments using an encryption algorithm, which are then sent by the edge device to neighboring devices in the communication network through a secure tunnel. The global gradient module is used to perform encryption operations on each encrypted gradient fragment using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments, and to perform ciphertext aggregation and randomization operations on the ciphertext gradient fragments to generate a global gradient. The incremental update module is used to decrypt the global gradient, generate a plaintext gradient sum, and perform an incremental update operation on the hierarchical adapter based on the plaintext gradient sum.

[0008] Furthermore, to achieve the above objectives, the present invention also provides a computer device, the computer device including a memory, a processor, and an incremental update program for an edge device stored in the memory and executable on the processor, wherein the incremental update program for the edge device, when executed by the processor, implements the steps of the incremental update method for the edge device as described above.

[0009] Furthermore, to achieve the above objectives, the present invention also provides a computer-readable storage medium storing an incremental update program for an edge device, wherein the incremental update program for the edge device, when executed by a processor, implements the steps of the incremental update method for the edge device as described above.

[0010] Beneficial Effects: This invention relates to the field of edge computing technology and can be applied to business system platforms in communications, healthcare, and fintech. It discloses an incremental update method for edge devices, comprising: constructing a communication network based on the network access request of the edge device; inputting the new task into the hierarchical adapter of the edge device and outputting gradient differences; converting the gradient differences into encrypted gradient fragments using an encryption algorithm, and sending the encrypted gradient fragments to neighboring devices in the communication network through a secure tunnel; performing encryption operations on each encrypted gradient fragment using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments, and performing ciphertext aggregation and randomization operations on the ciphertext gradient fragments to generate a global gradient; decrypting the global gradient to generate a plaintext gradient sum, and performing an incremental update operation on the hierarchical adapter based on the plaintext gradient sum. This invention enables multiple edge devices to generate gradient differences in the adapter through local data and exchange encrypted gradient fragments through the communication network to update the local adapter, improving communication efficiency and update performance. Attached Figure Description

[0011] The present invention will be further described below with reference to the accompanying drawings and embodiments. In the accompanying drawings: Figure 1 This is a schematic diagram of an application environment for the incremental update method for edge devices in one embodiment of the present invention; Figure 2 This is a flowchart illustrating an embodiment of the incremental update method for edge devices according to the present invention; Figure 3 This is a schematic diagram of the functional modules of a preferred embodiment of the incremental update device for edge devices of the present invention; Figure 4 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention; Figure 5 This is another structural schematic diagram of a computer device according to one embodiment of the present invention. Detailed Implementation

[0012] It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the invention.

[0013] The incremental update method for edge devices provided in this embodiment of the invention can be applied to, for example... Figure 1In this application environment, the user terminal communicates with the server via a network. The server can construct a communication network based on the network access request from the edge device; input new tasks into the hierarchical adapter of the edge device and output gradient differences; convert the gradient differences into encrypted gradient fragments using an encryption algorithm, and send the encrypted gradient fragments to neighboring devices in the communication network through a secure tunnel; perform encryption operations on each encrypted gradient fragment using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments, and perform ciphertext aggregation and randomization operations on the ciphertext gradient fragments to generate a global gradient; decrypt the global gradient to generate a plaintext gradient sum, and perform an incremental update operation on the hierarchical adapter based on the plaintext gradient sum. This invention allows multiple edge devices to generate gradient differences in the adapter through local data and exchange encrypted gradient fragments through the communication network to update the local adapter, improving communication efficiency and update performance. The user terminal can be, but is not limited to, various personal computers, laptops, smartphones, tablets, and portable wearable devices. The server can be implemented using a standalone server or a server cluster consisting of multiple servers. The invention will be described in detail below through specific embodiments.

[0014] Please see Figure 2 , Figure 2 This is a flowchart illustrating an embodiment of the incremental update method for edge devices provided by the present invention. It should be noted that although a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than that shown here.

[0015] like Figure 2 As shown, the incremental update method for edge devices proposed in this invention includes the following steps: S100. Construct a communication network and a secure tunnel based on the network access request sent by the edge device; S200: Obtain the new task, input the new task into the pre-configured hierarchical adapter of the edge device for training, and output the gradient difference; S300: The gradient difference is converted into encrypted gradient fragments using an encryption algorithm, and the edge device sends the encrypted gradient fragments to neighboring devices in the communication network through a secure tunnel; S400. Encryption operation is performed on each encryption gradient fragment using the additive homomorphic encryption algorithm to generate ciphertext gradient fragments. Ciphertext aggregation and randomization operations are then performed on the ciphertext gradient fragments to generate a global gradient. S500: Decrypt the global gradient to generate a plaintext gradient sum, and perform an incremental update operation on the hierarchical adapter based on the plaintext gradient sum.

[0016] In this embodiment, when an edge device initiates a network access request, it first initiates a device identity authentication process. The system adopts a certificate verification mechanism based on Public Key Infrastructure (PKI). The device needs to load its own digital certificate, which is compared with the information of the Root Certificate Authority (Root CA). After successful verification, the system generates a short-term access token (using JSONWeb Token, JWT format) with a validity period of 1 hour to confirm the legitimacy of the device's identity and prevent unauthorized devices from accessing the network.

[0017] After successful identity authentication, the device will register with the super node in the network. The super node will assign a list of neighboring devices to the device based on its zone, thus completing the dynamic networking. In terms of communication protocol selection, the transport layer adopts the QUIC protocol based on the User Datagram Protocol (UDP), significantly reducing communication handshake latency; the encryption layer uses Advanced Encryption Standard 256-bit - Galois / Counter Mode (AES-256-GCM) to encrypt data frames; the authentication layer uses the Elliptic Curve Digital Signature Algorithm - Secure Hash Algorithm 384 (ECDSA-SHA384) to ensure message integrity and prevent data tampering; key exchange uses the X25519 Elliptic Curve Diffie-Hellman (ECDH) algorithm to ensure forward security, meaning that even if the session key is leaked later, previous communication data will not be decrypted. Through this multi-layered protocol stack, a secure tunnel is established between the device and neighboring devices, providing security for subsequent data transmission.

[0018] After network access is established, the edge device acquires new tasks, such as a new smart air conditioner category recognition task in a smart home scenario or a new part defect type detection task in an industrial scenario. These new tasks are input into a hierarchical adapter pre-configured in the edge device for training. The hierarchical adapter consists of two parts: a static adapter and a dynamic adapter. The static adapter stores the device's inherent knowledge in the device's TrustZone and remains frozen during training to prevent the loss of old knowledge. The dynamic adapter, on the other hand, learns the knowledge of the new task and is an updatable part, accounting for only 0.8% of the total model parameters (only 420KB for a ResNet-50 model), greatly reducing the training burden on the edge device. During training, the system first freezes the old adapter (i.e., the static adapter and the already trained dynamic adapter part) and only trains the new adapter head to adapt to the new task. After training is complete, the gradient difference is obtained by calculating the difference in parameters between the new and old adapters. During the calculation process, the system sets a threshold (default 0.01) to retain only gradient data where the parameter change exceeds 1% of the absolute value of the old parameter, generates a sparse increment matrix, and stores the gradient difference in a compressed format of "index-value-matrix shape", which greatly reduces the amount of data. For example, the gradient difference of the ResNet-50 adapter can be reduced from 420KB to 5.4KB after compression, saving bandwidth for subsequent data transmission.

[0019] After obtaining the gradient difference, the system uses the Shamir secret sharing algorithm to divide the gradient difference into multiple fragments (the default is 5 fragments, and at least 3 fragments are needed to reassemble the complete gradient difference). Then, for each fragment, the system first obtains the public key of the receiving neighbor device, derives a symmetric encryption key from the public key, encrypts the fragment using the AES-256-GCM algorithm, and generates a Hash-based Message Authentication Code (HMAC) for subsequent verification of the fragment's integrity, ultimately forming encrypted gradient fragments. The edge device then sends the encrypted gradient fragments to neighbor devices in the communication network through a previously established secure tunnel. During transmission, the multi-layered encryption and authentication mechanism of the secure tunnel ensures that the encrypted gradient fragments are not stolen, tampered with, or intercepted, guaranteeing the security of data transmission.

[0020] Upon receiving the encrypted gradient fragment, the neighboring device first verifies its HMAC value to confirm that the fragment has not been tampered with during transmission. If verification is successful, it sends the encrypted gradient fragment to the fog computing node. The fog computing node uses the Paillier additive homomorphic encryption algorithm to further encrypt the encrypted gradient fragment, generating ciphertext gradient fragments. The characteristic of additive homomorphic encryption allows addition operations to be performed on data in ciphertext form without prior decryption, avoiding privacy leaks during computation. The ciphertext gradient fragments are then uploaded to the cloud, where they are aggregated. To further enhance privacy protection, a random mask is added to the aggregation result for randomization. The addition of the random mask prevents attackers from reverse-engineering the original gradient information from the aggregated ciphertext, ultimately preventing the generation of a global gradient. Throughout the entire process, the gradient data remains encrypted, effectively resisting gradient inversion attacks and ensuring data privacy.

[0021] After generating the global gradient in the cloud, it is distributed to edge devices. Each edge device needs to collect encrypted gradient fragments transmitted from at least three different neighboring devices, reconstruct the complete private key using the threshold decryption mechanism of the Shamir secret sharing algorithm, and then use this private key to decrypt the global gradient, obtaining the sum of plaintext gradients. After decryption, the system performs incremental updates on the hierarchical adapter based on the sum of plaintext gradients. The update process employs a dynamic distillation algorithm. First, the KL divergence (Kullback-Leibler Divergence) between the outputs of the newly trained dynamic adapter and the old adapter is calculated as the knowledge distillation loss, ensuring that the new adapter retains the existing knowledge of the old adapter while learning new task knowledge. Then, the old adapter and the newly trained dynamic adapter are weighted and fused in a 7:3 ratio to generate the updated adapter. This fusion method ensures both the accuracy of the new task (typically exceeding 91%) and keeps the forgetting rate of the old task below 5%, effectively solving the catastrophic forgetting problem in traditional incremental updates and achieving secure and efficient incremental updates of the edge adapter.

[0022] In one embodiment, prior to step S100, the following is included: S001. When the edge device starts up, the edge device’s own digital certificate is obtained from the security chip of the edge device. S002. Verify the legitimacy of your own digital certificate through a root certificate authority; S003. When the self-digital certificate is verified, generate the device ID and short-term access token for the edge device.

[0023] In this embodiment, when an edge device (such as a home camera in a smart home or a sensor in an industrial setting) is started, it first retrieves its pre-stored digital certificate from its own security chip (such as an SE security chip). The security chip is a hardware module specifically designed to store sensitive information, possessing strong physical protection and encryption capabilities. It effectively prevents the illegal theft or tampering of digital certificates, ensuring the originality and security of the device's identity information, which is also the foundation for subsequent identity verification.

[0024] After obtaining its own digital certificate, the device sends the certificate to the Root Certificate Authority (Root CA) for verification. The Root CA is the highest trusted authority in the digital certificate system, and the root certificates it issues are immutable. During the verification process, the Root CA checks key information such as the validity of the digital certificate signature, the certificate's expiration date, and whether the device information in the certificate matches the attributes of the device requesting verification. Through this series of verifications, illegally forged digital certificates can be eliminated, ensuring that devices accessing the network are legitimately authorized edge devices, thus preventing unauthorized devices from intruding into the network at the source.

[0025] Once the edge device's digital certificate is verified by the root certificate authority, the system generates a unique device identifier (device ID) and a short-term access token. The device ID serves as the edge device's "identity number" within the entire communication network, uniquely identifying the device in subsequent network communication, data transmission, and task allocation, ensuring accurate location of the corresponding edge device for all operations. The short-term access token is generated in JSON Web Token (JWT) format, typically valid for one hour. The token contains key information such as the device ID and validity period, and is encrypted and signed with a private key. The purpose of the short-term access token is to provide temporary identity credentials for the device's subsequent network access and data interaction, avoiding the security risks associated with the leakage of long-term credentials. When the device needs to access the network or transmit data, it only needs to present this short-term access token, eliminating the need for repeated complex digital certificate verification. This ensures security while improving the efficiency of device access and data interaction.

[0026] In one embodiment, step S100 includes: S101, The super node receives the network access request sent by the edge device with a short-term access token; S102. Extract the region information of the edge device in the network access request, and the super node generates a list of neighboring devices based on the region information. S103. Based on the neighbor device list, establish a secure tunnel between the edge device and the neighbor device through a key exchange protocol and a neighbor device negotiation protocol; S104. Pre-configure the encryption parameters of the secure tunnel and build a communication network based on the encryption parameters.

[0027] In this embodiment, after the edge device completes identity authentication and obtains a short-term access token, it sends a network access request containing the short-term access token to the super node in the network. As the core coordinating node in the network, the super node first verifies the validity of the short-term access token, confirming that the token has not expired and the signature is valid. This further verifies the identity of the edge device, ensuring that only legitimate devices that have passed the previous identity authentication can apply for network access, thus blocking the intrusion of unauthorized devices at the network access stage.

[0028] Once the short-term access token is verified, the supernode extracts the zone information of the edge device from the network access request. This zone information is typically related to the device's physical deployment location or network affiliation. Based on this information, the supernode uses its maintained device topology database to filter out edge devices that are in the same or adjacent zones and are currently online, generating a neighbor device list. The purpose of generating the neighbor device list is to match newly joined devices with geographically or network-proximity communication partners, reducing subsequent data transmission latency, improving communication efficiency, and facilitating the construction of a regionalized network management system.

[0029] After obtaining the list of neighboring devices, the newly joined edge device establishes a secure tunnel with each neighboring device in the list. In this process, firstly, a session key is negotiated and generated between the two parties using the X25519 Elliptic Curve Diffie-Hellman (ECDH) key exchange protocol. This key is only valid within the current communication session and is not directly transmitted across the network, ensuring key security. Subsequently, based on the negotiated session key and a pre-defined neighboring device negotiation protocol, the communication rules and data exchange format between the two parties are defined, ultimately establishing a secure tunnel between the edge device and its neighboring devices. The establishment of the secure tunnel provides a private communication channel for subsequent data transmission, preventing data from being stolen or tampered with during transmission.

[0030] During the establishment of a secure tunnel, the system pre-configures a complete set of encryption parameters, covering technical parameters at multiple layers including the transport layer, encryption layer, and authentication layer. The transport layer uses the QUIC protocol based on User Datagram Protocol (UDP) to reduce communication handshake latency. The encryption layer uses Advanced Encryption Standard 256-bit - Galois / Counter Mode (AES-256-GCM) to encrypt transmitted data frames. The authentication layer uses the Elliptic Curve Digital Signature Algorithm - SecureHash Algorithm 384 (ECDSA-SHA384) to ensure the integrity and immutability of transmitted messages. Based on these pre-defined encryption parameters, the secure tunnel between newly connected devices and neighboring devices possesses robust security capabilities. Numerous edge devices interconnect through their respective secure tunnels, ultimately forming a secure and efficient communication network, providing a stable network foundation for subsequent gradient fragment transmission, model updates, and other operations.

[0031] In one embodiment, step S200 includes: S201. Pre-configure the layered adapter in the edge device; S202. Obtain the newly added task and input the local dataset of the newly added task into the hierarchical adapter; S203. Calculate the divergence loss based on the local dataset of the new task; S204. Train the new dynamic adapter head of the hierarchical adapter using the divergence loss and the local dataset of the new task; S205. Obtain the weights of the old and new dynamic adapter heads before and after training the layered adapter, and calculate the difference between the weights of the old and new dynamic adapter heads to obtain the gradient difference.

[0032] In this embodiment, before the edge device officially participates in task training, a hierarchical adapter is pre-configured in the device. This adapter is a core module specifically designed for lightweight operation and incremental learning of edge devices, and consists of two parts: a static adapter and a dynamic adapter. The static adapter preserves the inherent knowledge of the edge device, such as operating parameters related to the device's hardware characteristics and the processing logic of basic tasks. This information is stored in the device's TrustZone and remains frozen during subsequent training and updates to prevent the loss of the device's original core capabilities. The dynamic adapter, on the other hand, is used to learn and adapt the knowledge of new tasks, accounting for only 0.8% of the total model parameters (for example, the dynamic adapter for the ResNet-50 model is only 420KB), significantly reducing the storage and computational pressure on the edge device and adapting to the hardware limitations of embedded devices with limited memory.

[0033] When an edge device receives a new task, such as "adding smart air conditioner category recognition" in a smart home scenario or "adding surface scratch defect detection for parts" in an industrial scenario, it will input the local dataset corresponding to the new task into a pre-configured hierarchical adapter. The local dataset consists of real data collected by the edge device during actual operation, without needing to be uploaded to the cloud, thus ensuring data privacy from the source and complying with privacy regulations such as GDPR.

[0034] Before training begins, the system calculates the divergence loss based on the local dataset for the new task. Here, KL divergence (Kullback-Leibler Divergence, i.e., relative entropy) loss is used. KL divergence is mainly used to measure the difference between two probability distributions. In this process, its role is to compare the probability distribution output by the old adapter (including the static adapter and the trained dynamic adapter part) with the probability distribution initially output by the new dynamic adapter head on the local dataset. This ensures that when the newly trained dynamic adapter head learns knowledge of the new task, it can retain the knowledge of the old task already mastered by the old adapter to the greatest extent, avoiding the "catastrophic forgetting" problem, that is, the situation where training for the new task causes a significant decrease in the processing ability of the old task.

[0035] Subsequently, the system uses the calculated KL divergence loss as the optimization objective and combines it with the local dataset of the new task to train the new dynamic adapter head of the hierarchical adapter. During training, the old adapter (especially the static adapter) remains frozen throughout, and only the parameters of the new dynamic adapter head are updated. This allows the new dynamic adapter head to quickly learn the features and patterns of the new task without disrupting the existing knowledge system in the old adapter. For example, in an industrial defect detection task, the new dynamic adapter head will focus on learning the image features of the new defect type without affecting the detection logic of the original defect type.

[0036] After training, the system obtains the weight parameters of the old dynamic adapter head before training and the weight parameters of the new dynamic adapter head after training. The gradient difference is obtained by calculating the difference between these two sets of weight parameters. When calculating the gradient difference, the system sets a default threshold (usually 0.01), retaining only parameter differences where the weight change exceeds 1% of the absolute value of the old weights, generating sparse gradient difference data, and storing it in a compressed format of "index-value-matrix shape". This processing method can significantly compress the amount of gradient difference data; for example, the gradient difference of the ResNet-50 adapter can be reduced from 420KB to 5.4KB after compression, greatly reducing the bandwidth consumption and energy consumption of subsequent data transmission, adapting to the communication and hardware resource limitations of edge devices.

[0037] In one embodiment, step S300 includes: S301. The gradient difference is divided into several sub-gradient difference matrices using a secret sharing algorithm; S302, Match the public keys of different neighboring devices in the communication network for each sub-gradient difference matrix; S303. Calculate the edge message authentication code for each sub-gradient difference matrix using an encryption algorithm to generate encrypted gradient fragments; S304. Edge devices send encrypted gradient fragments to neighboring devices in the communication network through a secure tunnel; S305. The neighboring device calculates the neighbor message verification code based on the encryption gradient fragment; S306. Compare the edge message verification code with the neighbor message verification code to determine whether the encryption gradient fragment is complete; S307. When the edge message verification code is consistent with the neighbor message verification code, it is determined that the encryption gradient fragment is complete, and the neighbor device receives the encryption gradient fragment.

[0038] In this embodiment, after obtaining the gradient difference, to ensure the security and privacy of data transmission, the system uses a secret sharing algorithm (specifically the Shamir secret sharing algorithm) to divide the gradient difference into several sub-gradient difference matrices. The core logic of this algorithm is to split the complete gradient difference into multiple fragments (the default setting is to split it into 5 fragments, and at least 3 fragments are required to reconstruct the complete gradient difference). A single sub-gradient difference matrix cannot reflect the information of the complete gradient difference. Even if a fragment is stolen, an attacker cannot reconstruct the original gradient data, thus reducing the risk of privacy leakage from the data splitting level.

[0039] After segmentation, the system matches each sub-gradient difference matrix with the public keys of different neighboring devices in the communication network. These public keys are generated and stored in the system when the neighboring devices register with the network. They are part of an asymmetric encryption system. The public key can be publicly used to encrypt data, but only the corresponding private key can decrypt it. By matching different sub-gradient difference matrices with the public keys of different neighboring devices, it ensures that each sub-gradient difference matrix can only be decrypted by the corresponding target neighboring device, further improving the directional security of data transmission.

[0040] Next, the system calculates an edge message authentication code (specifically a hash message authentication code, HMAC) for each sub-gradient difference matrix using an encryption algorithm. This HMAC is then combined with the sub-gradient difference matrix and the corresponding public key encryption result to generate encrypted gradient fragments. The edge message authentication code is calculated based on a preset key and the sub-gradient difference matrix data, effectively generating a unique "digital fingerprint" for each encrypted gradient fragment. This fingerprint can be used to verify whether the data has been tampered with. The sub-gradient difference matrix is ​​then encrypted using a symmetric encryption key derived from the public key of a matching neighboring device (using the AES-256-GCM algorithm), ensuring that the content of the sub-gradient difference matrix cannot be illegally intercepted.

[0041] Subsequently, the edge device sends the generated encrypted gradient fragments to the corresponding neighbor devices through the secure tunnel previously established with them. The secure tunnel is built on a multi-layered protection mechanism based on the QUIC protocol, AES-256-GCM encryption, etc., which can effectively resist the interception, theft and tampering of data during transmission, and provide a secure channel for the transmission of encrypted gradient fragments.

[0042] After receiving the encrypted gradient fragment, the neighboring device first extracts the sub-gradient difference matrix data from the fragment and calculates the neighbor message verification code (i.e., the HMAC value generated by the neighboring device) using the same algorithm and preset key as the edge device. The core of this step is to generate a "digital fingerprint" corresponding to the edge device through the same calculation logic, which is used for subsequent data integrity verification.

[0043] The neighboring device compares the edge message verification code sent by the edge device with its own calculated neighbor message verification code bit by bit. If they match perfectly, it means that the encryption gradient fragment has not been tampered with or damaged during transmission, and the data remains intact. If they do not match, it is determined that the encryption gradient fragment has been tampered with or transmitted incorrectly. The neighboring device will refuse to receive the fragment and may send a retransmission request to the edge device.

[0044] When the edge message verification code matches the neighbor message verification code, indicating that the encrypted gradient fragment is complete, the neighbor device receives the encrypted gradient fragment and stores it in its local secure storage area (such as the device's TrustZone or security chip), awaiting subsequent aggregation with fragments from other neighbor devices. This entire process, through end-to-end protection of "splitting-encryption-transmission-verification," ensures both the privacy of the gradient difference data and the integrity of data transmission, laying a secure foundation for the subsequent generation of the global gradient.

[0045] In one embodiment, step S400 includes: S401, The neighboring device transmits the encrypted gradient fragments, which have passed integrity verification, to the fog computing node; S402. The fog computing node uses an additive homomorphic encryption algorithm to perform encryption operations on each encrypted gradient fragment to generate ciphertext gradient fragments. S403. The fog computing node transmits the ciphertext gradient fragments to the cloud, and the cloud generates a random mask for each ciphertext gradient fragment. S404. Aggregate the ciphertext gradient fragments by ciphertext multiplication to generate aggregated ciphertext; S405. Perform random blinding processing on the aggregated ciphertext and random mask to generate a global gradient.

[0046] In this embodiment, after the neighboring device completes the integrity verification of the encrypted gradient fragments and receives the fragments, it transmits these verified encrypted gradient fragments to the fog computing node. The fog computing node, as an intermediate computing layer node between the edge device and the cloud, possesses certain computing and storage capabilities, effectively alleviating the processing pressure on the cloud while shortening data transmission distance, reducing latency, and adapting to the real-time requirements of edge computing scenarios. Its core function is to perform preliminary processing on the encrypted data transmitted from the edge device, providing a secure foundation for subsequent aggregation operations in the cloud.

[0047] After receiving encrypted gradient fragments, the fog computing node performs further encryption operations on each fragment using an additive homomorphic encryption algorithm, ultimately generating ciphertext gradient fragments. The specific additive homomorphic encryption algorithm used here is the Paillier algorithm. Its core feature is that it supports direct addition operations in the ciphertext state, without prior decryption. This means that the fog computing node can complete the encryption process without obtaining the plaintext information of the encrypted gradient fragments, fundamentally avoiding the privacy risk of gradient data leakage during intermediate processing. It also provides algorithmic support for subsequent aggregation operations of multiple ciphertext gradient fragments in the cloud.

[0048] After generating the encrypted gradient fragments, the fog computing nodes transmit all the fragments to the cloud. The cloud, acting as the global coordination and computing center for the entire system, first generates a random mask for each received encrypted gradient fragment. The random mask is a set of randomly generated values ​​used to "interfere" with the encrypted gradient fragments. Even if the subsequently aggregated encrypted information is illegally obtained, attackers cannot deduce the original gradient information from the encrypted data with the random mask, further enhancing data privacy protection and meeting the requirements of privacy regulations such as GDPR for sensitive data protection.

[0049] Subsequently, the cloud performs ciphertext multiplication on all ciphertext gradient fragments with random masks to generate aggregated ciphertext. This ciphertext multiplication operation is based on the characteristics of additive homomorphic encryption algorithms, performing the fusion calculation of multiple ciphertext gradient fragments in the ciphertext state to obtain a ciphertext result that reflects the sum of gradient information from all edge devices. The entire aggregation process is conducted entirely within the ciphertext domain, without involving plaintext data, completely eliminating the possibility of privacy leaks of gradient data during the aggregation stage and ensuring the security of local data on edge devices.

[0050] Finally, the cloud performs random blinding processing on the generated aggregated ciphertext and the random masks previously generated for each ciphertext gradient fragment. This step eliminates the "interference" of the random masks on the aggregation result by performing specific operations on the aggregated ciphertext and all random masks, while retaining the global gradient information contained in the aggregated ciphertext, ultimately generating the global gradient. The global gradient integrates the gradient update information of all edge devices participating in the training, accurately reflecting the optimization direction of the new task for the hierarchical adapter, and providing reliable parameter basis for the incremental updates of the edge device hierarchical adapter. The entire process, from the encryption processing of the fog computing node to the aggregation and blinding operations in the cloud, forms a three-level security protection system of "edge-fog-cloud", which not only protects data privacy but also ensures the accuracy and effectiveness of the global gradient.

[0051] In one embodiment, step S500 includes: S501: The cloud transmits the deblinding parameters to the edge device; S502, The edge device calculates the aggregate key for the encrypted gradient fragments using a secret sharing algorithm; S503. Using a decryption algorithm, the global gradient is deblinded and decrypted based on the aggregation key and deblinding parameters to generate the plaintext gradient sum. S504. Based on the sum of plaintext gradients, the edge device performs incremental updates to the hierarchical adapter.

[0052] In this embodiment, after the global gradient is generated in the cloud, the random mask in the global gradient is removed to obtain the deblinding parameters. These deblinding parameters are then transmitted to the various edge devices participating in the training. During transmission, the data is transmitted through a previously constructed secure tunnel. The secure tunnel employs multiple protection mechanisms, including the QUIC protocol and AES-256-GCM encryption, to ensure that the deblinding parameters are not stolen or tampered with during transmission, providing a secure and reliable parameter foundation for subsequent processing by the edge devices.

[0053] After receiving the deblinding parameters, the edge device calculates the aggregate key for the encrypted gradient fragments using a secret sharing algorithm (specifically, the Shamir secret sharing algorithm). Previously, when the edge device divided the gradient difference into sub-gradient difference matrices, it used a "3 / 5 threshold" Shamir secret sharing mechanism, requiring key fragments corresponding to at least three encrypted gradient fragments to reassemble a complete aggregate key. The edge device collects key fragments corresponding to encrypted gradient fragments from different neighboring devices and, through the reassembly logic of the secret sharing algorithm, merges these fragments to generate an aggregate key for decrypting the global gradient. This key is only valid within this update process and is not directly transmitted over the network, ensuring key security.

[0054] After obtaining the aggregation key, the edge devices use a decryption algorithm, combining the aggregation key with deblinding parameters, to sequentially perform deblinding and decryption operations on the global gradient. The deblinding operation primarily eliminates the influence of the initial random mask added in the cloud on the global gradient, restoring the true ciphertext aggregation result. The decryption operation uses the aggregation key to decrypt the ciphertext aggregation result, ultimately generating the plaintext gradient sum. The decryption algorithm here matches the Paillier additive homomorphic encryption algorithm used in fog computing node encryption, ensuring accurate restoration of plaintext data reflecting gradient updates from all edge devices, providing clear parameter basis for the layered adapter update.

[0055] After obtaining the plaintext gradient sum, the edge device incrementally updates the hierarchical adapter based on this data. During the update process, the edge device follows the architectural characteristics of the hierarchical adapter, keeping the static adapter frozen—the static adapter is stored in the device's TrustZone, which solidifies the device's inherent knowledge, and the freezing operation prevents the loss of old core capabilities. Simultaneously, the parameters corresponding to the plaintext gradient sum are updated to the dynamic adapter. The dynamic adapter, as the core module for adapting to new tasks, accounts for only 0.8% of the total model parameters (e.g., the dynamic adapter of the ResNet-50 model is only 420KB). During the update, a dynamic distillation algorithm is used to weight and fuse the new parameters with the old dynamic adapter parameters (typically, the old parameters have a weight of 0.7, and the new parameters have a weight of 0.3). This ensures the accuracy of the new task (e.g., the accuracy of new defect identification in industrial defect detection scenarios can reach 95.7%) while keeping the old task forgetting rate below 5%, effectively solving the "catastrophic forgetting" problem in traditional incremental updates. Ultimately, this completes the secure incremental update of the hierarchical adapter, allowing the edge device to efficiently adapt to new task requirements.

[0056] In one embodiment, an incremental update apparatus for an edge device is provided, which corresponds one-to-one with the incremental update method for the edge device described in the above embodiments. (Refer to...) Figure 3 , Figure 3 This is a schematic diagram of the functional modules of a preferred embodiment of the incremental update device for the edge device of the present invention. The modules include a network construction module 10, a gradient difference module 20, a gradient fragmentation module 30, a global gradient module 40, and an incremental update module 50. Detailed descriptions of each functional module are as follows: Network construction module 10 is used to construct a communication network and a secure tunnel based on the network access request sent by the edge device; Gradient difference module 20 is used to acquire new tasks, input the new tasks into the pre-configured hierarchical adapter of the edge device for training, and output gradient difference; Gradient fragmentation module 30 is used to convert the gradient difference into encrypted gradient fragments using an encryption algorithm, and the edge device sends the encrypted gradient fragments to neighboring devices in the communication network through a secure tunnel. The global gradient module 40 is used to perform encryption operations on each encrypted gradient fragment using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments, and to perform ciphertext aggregation and randomization operations on the ciphertext gradient fragments to generate a global gradient. The incremental update module 50 is used to decrypt the global gradient, generate a plaintext gradient sum, and perform an incremental update operation on the hierarchical adapter based on the plaintext gradient sum.

[0057] In one embodiment, the device verification module includes: The certificate acquisition unit is used to acquire the edge device's own digital certificate from the edge device's security chip when the edge device starts up; The certificate verification unit is used to verify the legitimacy of its own digital certificate through the root certificate authority. The verification completion unit is used to generate the device ID and short-term access token of the edge device when the digital certificate of the device itself is verified.

[0058] In one embodiment, the network construction module 10 includes: The network access request unit is used by the supernode to receive network access requests sent by edge devices with short-term access tokens; The neighbor device unit is used to extract the region information of the edge device in the network access request, and the super node generates a list of neighbor devices based on the region information. The secure tunnel unit is used to establish a secure tunnel between the edge device and neighboring devices based on the neighboring device list, through a key exchange protocol and a neighboring device negotiation protocol. The communication network unit is used to pre-configure the encryption parameters of the secure tunnel and construct the communication network based on the encryption parameters.

[0059] In one embodiment, the gradient difference module 20 includes: A layered adapter unit for pre-configuring layered adapters in edge devices; A new task unit is added to acquire new tasks and input the local dataset of the new tasks into the hierarchical adapter. The divergence loss unit is used to calculate the divergence loss based on the local dataset of the new task. An adapter training unit is used to train a new dynamic adapter head of the hierarchical adapter using the divergence loss and a local dataset of the new task. The gradient difference unit is used to obtain the weights of the old and new dynamic adapter heads before and after training of the hierarchical adapter, and to calculate the difference between the weights of the old and new dynamic adapter heads to obtain the gradient difference.

[0060] In one embodiment, the gradient fragmentation module 30 includes: The fragmentation unit is used to divide the gradient difference into several sub-gradient difference matrices using a secret sharing algorithm; The public key matching unit is used to match the public keys of different neighboring devices in the communication network for each sub-gradient difference matrix. The encrypted gradient fragment unit is used to calculate the edge message authentication code for each sub-gradient difference matrix using an encrypted algorithm, thereby generating encrypted gradient fragments. The fragment transmission unit is used by edge devices to send encrypted gradient fragments to neighboring devices in the communication network through a secure tunnel; The neighbor message verification code unit is used by the neighbor device to calculate the neighbor message verification code based on the encryption gradient fragment; The fragment verification unit is used to compare the edge message verification code with the neighbor message verification code to determine whether the encryption gradient fragment is complete. The fragment receiving unit is used to determine that the encryption gradient fragment is complete when the edge message verification code is consistent with the neighbor message verification code, and the neighbor device receives the encryption gradient fragment.

[0061] In one embodiment, the global gradient module 40 includes: Fog computing node units are used by neighboring devices to transmit encrypted gradient fragments that have passed integrity verification to the fog computing node; The ciphertext gradient fragment unit is used by the fog computing node to perform an encryption operation on each encrypted gradient fragment using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments. A random mask unit is used to transmit the ciphertext gradient fragments to the cloud by fog computing nodes, wherein the cloud generates a random mask for each ciphertext gradient fragment. An aggregated ciphertext unit is used to aggregate the ciphertext gradient fragments through ciphertext multiplication to generate aggregated ciphertext. A global gradient unit is used to perform random blinding processing on the aggregated ciphertext and the random mask to generate a global gradient.

[0062] In one embodiment, the incremental update module 50 includes: The deblinding parameter unit is used to transmit deblinding parameters from the cloud to the edge device; An aggregated key unit is used by edge devices to calculate the aggregated key for cryptographic gradient fragments using a secret sharing algorithm. The plaintext gradient summation unit is used to generate the plaintext gradient sum by performing deblinding and decryption operations on the global gradient based on the aggregation key and deblinding parameters using a decryption algorithm. The incremental update unit is used for edge devices to perform incremental updates on the hierarchical adapter based on the sum of plaintext gradients.

[0063] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 4As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used for communication with external user terminals via a network connection. When the computer program is executed by the processor, it implements the functions or steps of an incremental update method for an edge device on the server side.

[0064] In one embodiment, a computer device is provided, which may be a user terminal, and its internal structure diagram may be as follows: Figure 5 As shown, the computer device includes a processor, memory, network interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The network interface is used to communicate with an external server via a network connection. When the computer program is executed by the processor, it implements the user-side functions or steps of an incremental update method for an edge device. In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps: Build a communication network and secure tunnel based on the network access requests sent by edge devices; The system acquires a new task and inputs the new task into a pre-configured hierarchical adapter of the edge device for training, outputting the gradient difference. The gradient difference is converted into encrypted gradient fragments using an encryption algorithm, and these encrypted gradient fragments are then sent by the edge device to neighboring devices in the communication network through a secure tunnel. Each encryption gradient fragment is encrypted using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments. Then, ciphertext aggregation and randomization operations are performed on the ciphertext gradient fragments to generate a global gradient. The global gradient is decrypted to generate a plaintext gradient sum, and an incremental update operation is performed on the hierarchical adapter based on the plaintext gradient sum.

[0065] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, the computer program performing the following steps when executed by a processor: Build a communication network and secure tunnel based on the network access requests sent by edge devices; The system acquires a new task and inputs the new task into a pre-configured hierarchical adapter of the edge device for training, outputting the gradient difference. The gradient difference is converted into encrypted gradient fragments using an encryption algorithm, and these encrypted gradient fragments are then sent by the edge device to neighboring devices in the communication network through a secure tunnel. Each encryption gradient fragment is encrypted using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments. Then, ciphertext aggregation and randomization operations are performed on the ciphertext gradient fragments to generate a global gradient. The global gradient is decrypted to generate a plaintext gradient sum, and an incremental update operation is performed on the hierarchical adapter based on the plaintext gradient sum.

[0066] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions on the server side and user side in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0067] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0068] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0069] It should be noted that if any software tools or components not belonging to this company appear in the embodiments of this application, they are merely illustrative examples and do not represent actual use. The embodiments described above are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. An incremental update method for edge devices, characterized in that, Includes the following steps: Build a communication network and secure tunnel based on the network access requests sent by edge devices; The system acquires a new task and inputs the new task into a pre-configured hierarchical adapter of the edge device for training, outputting the gradient difference. The gradient difference is converted into encrypted gradient fragments using an encryption algorithm, and these encrypted gradient fragments are then sent by the edge device to neighboring devices in the communication network through a secure tunnel. Each encryption gradient fragment is encrypted using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments. Then, ciphertext aggregation and randomization operations are performed on the ciphertext gradient fragments to generate a global gradient. The global gradient is decrypted to generate a plaintext gradient sum, and an incremental update operation is performed on the hierarchical adapter based on the plaintext gradient sum.

2. The incremental update method for edge devices as described in claim 1, characterized in that, Before constructing the communication network and secure tunnel based on the network access request sent by the edge device, the following steps are included: When the edge device starts up, its own digital certificate is obtained from the edge device's security chip; Verify the legitimacy of your own digital certificate through a root certificate authority; When the digital certificate itself is verified, a device ID and a short-term access token for the edge device are generated.

3. The incremental update method for edge devices as described in claim 1, characterized in that, The construction of the communication network and secure tunnel based on the network access request sent by the edge device includes: The supernode receives network access requests sent by edge devices with short-term access tokens; The super node extracts the region information of the edge device in the network access request, and generates a list of neighboring devices based on the region information. Based on the list of neighboring devices, a secure tunnel between the edge device and neighboring devices is established through a key exchange protocol and a neighboring device negotiation protocol. The encryption parameters for the secure tunnel are pre-configured, and the communication network is built based on these parameters.

4. The incremental update method for edge devices as described in claim 1, characterized in that, The process of acquiring a new task, inputting the new task into a pre-configured hierarchical adapter of the edge device for training, and outputting the gradient difference includes: Pre-configure the hierarchical adapter in the edge device; Obtain the newly added task and input the local dataset of the newly added task into the hierarchical adapter; Calculate the divergence loss based on the local dataset of the new task; The new dynamic adapter head of the hierarchical adapter is trained using the divergence loss and the local dataset of the new task; Obtain the weights of the old and new dynamic adapter heads before and after training the hierarchical adapter, and calculate the difference between the weights of the old and new dynamic adapter heads to obtain the gradient difference.

5. The incremental update method for edge devices as described in claim 1, characterized in that, The step of converting the gradient difference into encrypted gradient fragments using an encryption algorithm, and then sending these encrypted gradient fragments from the edge device to neighboring devices in the communication network via a secure tunnel, includes: The gradient difference is divided into several sub-gradient difference matrices using a secret sharing algorithm; Match the public keys of different neighboring devices in the communication network to each sub-gradient difference matrix; An edge message authentication code is calculated for each sub-gradient difference matrix using an encryption algorithm to generate encrypted gradient fragments. Edge devices send encrypted gradient fragments to neighboring devices in the communication network through secure tunnels; The neighboring device calculates the neighbor message verification code based on the encrypted gradient fragment; The edge message verification code is compared with the neighbor message verification code to determine whether the encryption gradient fragment is complete. When the edge message verification code matches the neighbor message verification code, the encryption gradient fragment is determined to be complete, and the neighbor device receives the encryption gradient fragment.

6. The incremental update method for edge devices as described in claim 1, characterized in that, The process of performing encryption operations on each encryption gradient fragment using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments, and then performing ciphertext aggregation and randomization operations on the ciphertext gradient fragments to generate a global gradient includes: The neighboring device transmits the encrypted gradient fragments, which have passed integrity verification, to the fog computing node; The fog computing node uses an additive homomorphic encryption algorithm to perform encryption operations on each encrypted gradient fragment, generating ciphertext gradient fragments; The fog computing node transmits the ciphertext gradient fragments to the cloud, where the cloud generates a random mask for each ciphertext gradient fragment. The ciphertext gradient fragments are aggregated by ciphertext multiplication to generate aggregated ciphertext; The aggregated ciphertext and random mask are then subjected to randomized blinding processing to generate a global gradient.

7. The incremental update method for edge devices as described in claim 1, characterized in that, The step of decrypting the global gradient to generate a plaintext gradient sum, and performing an incremental update operation on the hierarchical adapter based on the plaintext gradient sum, includes: The cloud transmits the deblinding parameters to the edge devices; Edge devices calculate the aggregate key for encrypted gradient fragments using a secret sharing algorithm; The decryption algorithm performs deblinding and decryption operations on the global gradient based on the aggregation key and deblinding parameters to generate the plaintext gradient sum. Based on the sum of plaintext gradients, the edge device performs incremental updates to the hierarchical adapter.

8. An incremental update device for an edge device, characterized in that, The incremental update device for the edge device includes: The network construction module is used to build communication networks and secure tunnels based on network access requests sent by edge devices. The gradient difference module is used to acquire new tasks, input the new tasks into the pre-configured hierarchical adapter of the edge device for training, and output the gradient difference. The gradient fragmentation module is used to convert the gradient difference into encrypted gradient fragments using an encryption algorithm, which are then sent by the edge device to neighboring devices in the communication network through a secure tunnel. The global gradient module is used to perform encryption operations on each encrypted gradient fragment using an additive homomorphic encryption algorithm to generate ciphertext gradient fragments, and to perform ciphertext aggregation and randomization operations on the ciphertext gradient fragments to generate a global gradient. The incremental update module is used to decrypt the global gradient, generate a plaintext gradient sum, and perform an incremental update operation on the hierarchical adapter based on the plaintext gradient sum.

9. A computer device, characterized in that, The computer device includes a memory, a processor, and an incremental update program for the edge device stored in the memory and executable on the processor. When executed by the processor, the incremental update program for the edge device implements the steps of the incremental update method for the edge device as described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The storage medium stores an incremental update program for the edge device, which, when executed by a processor, implements the steps of the incremental update method for the edge device as described in any one of claims 1-7.

Images