Cross-domain collaborative privacy protection method and system, medium and product

Abstract

The invention discloses a cross-domain collaborative privacy protection method and system, a medium and a product, and relates to the field of data processing systems specially suitable for the management purpose, and the method comprises the steps: carrying out the batch forward propagation operation of samples in a local sample data set based on a feature extraction network, and obtaining an intermediate activation value; determining an intersection sample set with an external computing node, extracting a corresponding intermediate activation value, and executing back propagation operation to obtain a partial effective gradient; performing forward propagation and back propagation on the residual samples to obtain residual effective gradients, and generating an effective gradient set; performing encryption operation on the effective gradient set to generate a local ciphertext gradient; sending the local ciphertext gradient to an aggregation server, and receiving a global ciphertext gradient; and executing decryption operation on the global ciphertext gradient to generate a plaintext global gradient, and updating a weight parameter of the feature extraction network. By implementing the method and the device, the problem of idle computing resources caused by serial privacy intersection can be reduced, and the data processing efficiency is optimized.

Description

Technical Field

[0001] This application relates to the field of data processing systems specifically for administrative purposes, and more particularly to a cross-domain collaborative privacy protection method, system, medium, and product. Background Technology

[0002] In scenarios such as smart parks, cross-border trade, and government data collaboration, data is often scattered across different security domains, including customs, park operators, and resident companies. In order to explore the comprehensive value of data (such as building corporate credit profiles), all parties need to conduct cross-domain data joint modeling without disclosing the privacy of the original data.

[0003] In related technologies, cross-domain privacy protection techniques mainly adopt a serial federated learning scheme based on privacy-preserving intersection (PSI) followed by model training. This scheme requires each participant to first interact through an encrypted protocol and calculate a set of sample IDs shared by both parties (i.e., the intersection), and then extract features only from samples within this intersection for model training.

[0004] However, during the communication interaction of privacy intersection, the local computing resources (CPU / GPU) are in a waiting state. After the intersection is completed, the database needs to be traversed again to extract features, which causes the overall training process to be fragmented and the system end-to-end latency to be high. Summary of the Invention

[0005] This application provides a cross-domain collaborative privacy protection method, system, medium, and product to reduce the problem of idle computing resources caused by serial privacy intersection and optimize data processing efficiency.

[0006] Firstly, this application provides a cross-domain collaborative privacy protection method applied to a data processing system. The method includes: performing batch forward propagation operations on samples in a local sample dataset based on a feature extraction network to obtain intermediate activation values ​​corresponding to some samples and storing them in a temporary storage area; determining the intersection sample set after performing a privacy set intersection protocol with an external computing node; extracting intermediate activation values ​​corresponding to the target sample in the intersection sample set from the temporary storage area and performing backpropagation operations to obtain partial effective gradients; performing forward and backpropagation operations on the remaining samples in the intersection sample set excluding the target sample to obtain the remaining effective gradients, and combining the partial effective gradients to generate an effective gradient set; performing encryption operations on the effective gradient set based on a homomorphic encryption public key to generate local ciphertext gradients; sending the local ciphertext gradients to an aggregation server and receiving global ciphertext gradients from the aggregation server; performing decryption operations on the global ciphertext gradients based on the local private key to generate plaintext global gradients, and updating the weight parameters of the feature extraction network according to the plaintext global gradients.

[0007] In the above embodiments, the data processing system processes the forward propagation computation and the privacy set intersection process in parallel. It uses the communication waiting time during the intersection process to pre-calculate and cache the intermediate activation values ​​of the samples. After the intersection is completed, the cached results can be directly used for partial backpropagation, avoiding repeated calculation of the full intersection samples, reducing the idle time of computing resources, and improving the end-to-end efficiency of federated learning training.

[0008] In conjunction with some embodiments of the first aspect, in some embodiments, before the step of performing batch forward propagation operations on samples in the local sample dataset based on the feature extraction network to obtain intermediate activation values ​​corresponding to some samples and storing them in a temporary storage area, the method further includes: obtaining the intersection sample records determined in the historical training task, and counting the frequency of each sample in the local sample dataset in the intersection sample records; selecting a set of high-priority samples with a preset number of samples from the local sample dataset according to the order of occurrence frequency from high to low; when the capacity of the temporary storage area reaches a preset upper limit, retaining the intermediate activation values ​​corresponding to the high-priority sample set and deleting the intermediate activation values ​​corresponding to other sample data outside the high-priority sample set.

[0009] In the above embodiments, the data processing system analyzes historical intersection records to predict samples that may participate in future calculations and prioritizes caching the intermediate activation values ​​of these samples. With limited temporary storage capacity, the intelligent cache replacement strategy improves the cache hit rate, further reduces the recalculation overhead caused by cache misses, and optimizes the utilization efficiency of storage resources.

[0010] In conjunction with some embodiments of the first aspect, in some embodiments, the step of determining the intersection sample set after performing a privacy set intersection protocol with an external computing node specifically includes: generating a local Bloom filter based on local sample identifiers of the local sample dataset, and sending the local Bloom filter to the external computing node; receiving an external Bloom filter generated from external sample identifiers returned by the external computing node; mapping the local sample identifiers to the external Bloom filter to perform membership queries to determine a candidate intersection sample subset; and performing a privacy set intersection protocol on the candidate intersection sample subset and the external computing node to determine the intersection sample set.

[0011] In the above embodiments, before executing the expensive privacy set intersection protocol, the data processing system uses a Bloom filter for a low-cost pre-screening, which can quickly eliminate most non-intersection samples, narrow down the range of samples for subsequent accurate intersection, significantly reduce the communication overhead and computational complexity of the privacy set intersection stage, and improve the overall efficiency of determining the intersection sample set.

[0012] In conjunction with some embodiments of the first aspect, in some embodiments, before the step of extracting intermediate activation values ​​corresponding to the target samples in the intersection sample set from the temporary storage area and performing backpropagation to obtain partial effective gradients, the method further includes: querying the temporary storage area using the identifier of the target sample in the intersection sample set as an index to obtain the storage model version number associated with the corresponding intermediate activation value; when the storage model version number and the current model version number of the feature extraction network are inconsistent, marking the target sample as a sample that needs to be recalculated and including it in the remaining samples to re-perform forward propagation.

[0013] In the above embodiments, the data processing system adds a model version number verification mechanism to the cached intermediate activation values, ensuring that the intermediate activation values ​​used for backpropagation are consistent with the current model weight version, avoiding data inconsistency caused by model updates, ensuring the accuracy of gradient calculation, and thus ensuring stable convergence of model training.

[0014] In conjunction with some embodiments of the first aspect, in some embodiments, before the step of querying the temporary storage area using the identifier of the target sample in the intersection sample set as an index to obtain the storage model version number associated with the corresponding intermediate activation value, the method further includes: obtaining the current global iteration round identifier of the feature extraction network; checking the last update round identifier recorded in the metadata of the temporary storage area; and when the global iteration round identifier and the last update round identifier do not match, clearing the temporary storage area and marking all intersection samples as the samples that need to be recalculated.

[0015] In the above embodiments, the data processing system introduces a global iteration round identifier to verify the validity of the entire temporary storage area. This allows all cached data from the previous round to be invalidated at the start of a new training round, avoiding the risk of using stale intermediate activation values ​​across rounds. This ensures the consistency of training data from a macro perspective and simplifies cache management logic.

[0016] In conjunction with some embodiments of the first aspect, in some embodiments, before the step of performing encryption operations on the effective gradient set based on the homomorphic encryption public key to generate a local ciphertext gradient, the method further includes: determining a noise vector with the same dimension as the effective gradient set according to differential privacy budget parameters; generating a perturbation gradient that meets the differential privacy protection requirements according to the effective gradient set and the noise vector; and performing the encryption operation on the perturbation gradient as data to be encrypted.

[0017] In the above embodiments, the data processing system introduces a differential privacy mechanism before gradient encryption. By injecting precisely calibrated noise into the original gradient, this method provides quantifiable privacy protection for gradient information without relying on encryption algorithms. Even in the extreme case where homomorphic encryption is cracked, it can prevent attackers from accurately deducing the original sample information from the gradient, thus enhancing the defense-in-depth capability of the scheme.

[0018] In conjunction with some embodiments of the first aspect, in some embodiments, before determining the noise vector with the same dimension as the effective gradient set based on the differential privacy budget parameter, the method further includes: obtaining the cumulative training epochs of the current federated learning task; calculating the privacy budget decay coefficient corresponding to the current epoch based on a preset decay function and the cumulative training epochs; and adjusting the variance parameter of the noise vector generated based on the privacy budget decay coefficient.

[0019] In the above embodiments, the data processing system implements dynamic adjustment of the differential privacy budget. In the early stages of training, the samples have a significant impact on the model, so the system allocates a smaller privacy budget (i.e., adds more noise) to provide stronger privacy protection. As the model converges, the system gradually increases the privacy budget (i.e., reduces noise) to ensure the model's accuracy. This dynamic strategy balances the strength of privacy protection with model availability throughout the entire lifecycle of model training.

[0020] In a second aspect, embodiments of this application provide a data processing system comprising: one or more processors and a memory; the memory is coupled to the one or more processors and is used to store computer program code, the computer program code including computer instructions, wherein the one or more processors invoke the computer instructions to cause the data processing system to perform the method described in the first aspect and any possible implementation thereof.

[0021] Thirdly, embodiments of this application provide a computer-readable storage medium including instructions that, when executed on a data processing system, cause the data processing system to perform the method described in the first aspect and any possible implementation thereof.

[0022] Fourthly, embodiments of this application provide a computer program product containing instructions that, when the computer program product is run on a data processing system, cause the data processing system to perform the method described in the first aspect and any possible implementation thereof.

[0023] Understandably, the data processing system provided in the second aspect, the computer storage medium provided in the third aspect, and the computer program product provided in the fourth aspect are all used to execute the methods provided in the embodiments of this application. Therefore, the beneficial effects they can achieve can be referred to the beneficial effects in the corresponding methods, and will not be repeated here.

[0024] One or more technical solutions provided in the embodiments of this application have at least the following technical effects or advantages:

[0025] 1. By adopting a technical solution that processes forward propagation and privacy intersection in parallel and caches intermediate activation values, idle computing power is used for calculation while waiting for the intersection result. This effectively solves the problems of idle computing resources and high processing latency caused by serial processes in existing technologies, thereby improving the efficiency of cross-domain collaborative training.

[0026] 2. By adopting a technical solution that verifies the validity of the cache based on the model version number, it is possible to confirm whether the intermediate activation value in the cache matches the current model before using it. This effectively solves the problem of outdated cached data caused by model iteration, thereby achieving the accuracy of gradient calculation and the stability of model training.

[0027] 3. By employing a technique of injecting differential privacy noise before gradient encryption, quantifiable privacy protection is provided for gradient information, effectively solving the potential risk of gradient information leakage in homomorphic encryption aggregation schemes, and thus achieving a higher level of privacy protection. Attached Figure Description

[0028] Figure 1 This is a flowchart illustrating a privacy protection method for cross-domain collaboration in an embodiment of this application;

[0029] Figure 2 This is another flowchart illustrating the privacy protection method for cross-domain collaboration in this application embodiment;

[0030] Figure 3 This is a schematic diagram of the physical device structure of a data processing system in an embodiment of this application. Detailed Implementation

[0031] The terminology used in the following embodiments of this application is for the purpose of describing particular embodiments only and is not intended to be limiting of this application. As used in the specification of this application, the singular expressions “a,” “an,” “the,” “the,” and “this” are intended to include the plural expressions as well, unless the context clearly indicates otherwise. It should also be understood that the term “and / or” as used in this application refers to any or all possible combinations including one or more of the listed items.

[0032] Hereinafter, the terms "first" and "second" are used for descriptive purposes only and should not be construed as implying or suggesting relative importance or implicitly indicating the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature, and in the description of the embodiments of this application, unless otherwise stated, "multiple" means two or more.

[0033] In the cross-domain collaborative privacy protection scenario described in this application, multiple participants with different datasets are involved. For example, in a smart park scenario, the park operator, resident enterprises, and banks are all independent computing nodes, each possessing partial data about the enterprises, such as the operator's utility bill records, the enterprises' operating data, and the banks' credit records. To build a more comprehensive enterprise credit profile model (i.e., joint modeling), the parties need to collaborate on computation without disclosing their original data (such as specific payment amounts and operating profits). This process constitutes cross-domain collaborative privacy protection. The feature extraction network refers to a part of the deep learning model used by each participant to extract high-dimensional features from their original data. The intermediate activation value refers to the output generated when sample data is forward-propagated to an intermediate layer in the feature extraction network; this value can be used for subsequent backpropagation computation. Privacy Set Intersection (PSI) is a cryptographic protocol used to allow two or more participants to compute the intersection of their datasets without disclosing the contents of their respective sets. For example, it can identify those enterprises whose records are commonly held by all parties (identified by sample identifiers such as the enterprise's unified social credit code). Homomorphic encryption is an encryption technique that allows direct computation on ciphertext, and the decrypted result is identical to the result of the same computation on the plaintext. It can be used to securely aggregate gradients from various parties. Differential privacy, on the other hand, is a technical framework that provides quantifiable privacy guarantees by adding noise to the data to protect individual information.

[0034] The following describes the process of the method provided in this implementation. Please refer to [link / reference]. Figure 1 This is a flowchart illustrating a privacy protection method for cross-domain collaboration in this application embodiment.

[0035] S101. Based on the feature extraction network, perform batch forward propagation operations on the samples in the local sample dataset to obtain intermediate activation values ​​corresponding to some samples and store them in a temporary storage area.

[0036] Among them, the feature extraction network refers to a neural network model used to extract feature vectors from the original data; the local sample dataset refers to a data set containing multiple samples stored locally; the forward propagation operation refers to the process of inputting sample data into the neural network and calculating layer by layer until the output is obtained; the intermediate activation value refers to the output result of a certain intermediate layer of the network model; the temporary storage area refers to the storage space used to temporarily store the intermediate activation values, such as memory or cache.

[0037] Specifically, at the start of each training round of federated learning, the data processing system can initiate local computation tasks without waiting for the privacy set intersection to complete. The system reads sample data from the local dataset in batches and inputs these batches into the current feature extraction network. The network performs forward propagation on the data, stopping computation when it reaches a preset segmentation layer. The intermediate activation values ​​output by this layer, along with corresponding sample identifiers, the current model version number, and other metadata, are stored in a temporary storage area. This process continues until all local samples have been processed or the temporary storage area reaches its capacity limit.

[0038] In some embodiments, the storage of intermediate activation values ​​can be implemented in several ways: Optionally, the data processing system can use an in-memory hash table (key-value store) as a temporary storage area, with the sample identifier as the key and a structure composed of intermediate activation values ​​and metadata as the value. This method offers fast query speeds. Alternatively, the data processing system can serialize the intermediate activation values ​​and write them to a local disk file, and create an index file to support fast retrieval. This method supports larger-scale caching, but read and write speeds are relatively slow. It is understood that other methods can also be used to implement this step, such as using a distributed caching system like Redis; this is not limited here.

[0039] In some embodiments, the temporary storage area may be insufficient to cache the intermediate activation values ​​of all local samples. To address this, the data processing system employs a cache replacement strategy. For example, when the storage area is full, a Least Recently Used (LRU) strategy can be used to discard the intermediate activation value that has not been accessed for the longest time, making room for new computation results.

[0040] S102. After performing the privacy set intersection protocol with the external computing node, determine the intersection sample set.

[0041] In this context, external computing nodes refer to other participants in federated learning besides this data processing system; the privacy set intersection protocol is a cryptographic protocol used to find data item identifiers common to all participants without disclosing non-intersection data of each party; the intersection sample set refers to the set of sample identifiers that are owned by all participants and determined by the intersection protocol.

[0042] Specifically, concurrently with step S101, the data processing system initiates a privacy set intersection protocol in parallel with one or more external computing nodes. The data processing system uses all sample identifiers from its local sample dataset as input and engages in multiple rounds of encrypted communication with the external computing nodes. Depending on the specific protocol employed, this process may involve public key exchange, blind signatures, and cryptographic hash value comparison. After the protocol is completed, each participant receives the same intersection sample set, which contains the sample identifiers needed for subsequent model training.

[0043] In some embodiments, the intersection of privacy sets can be achieved in several ways: optionally, a protocol based on unintentional transfer (OT) extensions can be used, which requires fewer communication rounds and is more efficient; alternatively, a protocol based on Diffie-Hellman key exchange can also be used, which does not rely on public key infrastructure and is relatively simple to implement. It is understood that other methods can also be used to implement this step, such as protocols based on RSA blind signatures, which are not limited here.

[0044] In some embodiments, the privacy set intersection protocol may fail due to network interruption or node failure. In response, the data processing system will initiate a retry mechanism. The data processing system can set a preset timeout and a number of retries. If no response is received from the external node within the specified time or an error occurs during protocol execution, the intersection request will be re-initiated after a short wait. If the maximum number of retries is exceeded and the process still fails, the current training round will be terminated and the error recorded.

[0045] S103. Extract the intermediate activation values ​​corresponding to the target samples in the intersection sample set from the temporary storage area and perform backpropagation to obtain a partial effective gradient.

[0046] Here, target samples refer to the portion of samples in the intersection sample set whose corresponding intermediate activation values ​​have been successfully cached in the temporary storage area; backpropagation operation refers to the process of calculating the gradient according to the loss function and passing the gradient layer by layer from back to front; partial effective gradient refers to the gradient calculated only from this portion of target samples.

[0047] Specifically, after receiving the intersection sample set determined in step S102, the data processing system iterates through each sample identifier in the set. For each identifier, the data processing system uses it as an index to query the temporary storage area. If the query is successful, meaning the corresponding intermediate activation value is found, the sample is classified as a target sample. The data processing system uses this intermediate activation value, starting from its respective network layer, to complete the second half of the forward propagation operation to obtain the final output. It then combines this with the label value to calculate the loss and performs backpropagation to calculate the network weight gradient associated with the sample. This gradient is the partially effective gradient.

[0048] In some embodiments, the computational process for this step can be implemented in several ways: Optionally, the data processing system can process the target samples one by one, calculating and accumulating their gradients after processing each sample; alternatively, the data processing system can first filter out all target samples, then group their corresponding intermediate activation values ​​into a new batch, and perform the latter half of the batch's forward and backward propagation computations to utilize the parallel computing capabilities of hardware (such as GPUs). It is understood that other methods can also be used to implement this step, and no limitation is made here.

[0049] S104. Perform forward and backward propagation on the remaining samples in the intersection sample set except for the target sample to obtain the remaining effective gradients, and combine the partial effective gradients to generate an effective gradient set.

[0050] Among them, the remaining samples refer to the samples in the intersection sample set that could not be found in the temporary storage area (i.e., cache miss); the remaining effective gradients refer to the gradients calculated from the remaining samples; and the effective gradient set refers to the final gradient after merging the partial effective gradients with the remaining effective gradients.

[0051] Specifically, the data processing system identifies all intersection samples that failed to match the cache in step S103 as remaining samples. For these samples, the data processing system needs to execute the complete computation process from scratch: that is, read their original feature data from the local database, input them into the feature extraction network, and perform complete forward and backward propagation operations to calculate the remaining effective gradients. Finally, the data processing system sums or concatenates the remaining effective gradients with the partial effective gradients obtained in step S103 to form the complete set of effective gradients for this round of training.

[0052] In some embodiments, gradient merging can be implemented in several ways: Optionally, the data processing system adds the two gradient vectors element-wise to obtain a final gradient vector with the same dimension as the model parameters; alternatively, if the two gradients are computed and stored separately, the data processing system can manage them as a list or tuple and merge them in subsequent encryption and update steps. It is understood that other methods can also be used to implement this step, and no limitation is made here.

[0053] S105. Perform encryption operations on the effective gradient set based on the homomorphic encryption public key to generate local ciphertext gradients.

[0054] Among them, the homomorphic encryption public key is one of the pair of keys used to encrypt data in the homomorphic encryption scheme, and it is open to the public; the local ciphertext gradient refers to the ciphertext form obtained after homomorphic encryption of the effective gradient set calculated locally.

[0055] Specifically, after generating a complete set of valid gradients, the data processing system needs to encrypt them to send them to the aggregation server without revealing the plaintext gradients. The data processing system obtains the current homomorphic encryption public key from the aggregation server or key management center. Then, the data processing system iterates through each gradient value in the valid gradient set, calls the homomorphic encryption algorithm library, and uses the public key to encrypt the gradient value, generating the corresponding ciphertext. All encrypted gradient values ​​are then combined to form the local ciphertext gradient.

[0056] In some embodiments, the encryption operation can be implemented in several ways: Optionally, the Paillier homomorphic encryption scheme can be used, which supports ciphertext addition and ciphertext-plaintext multiplication, and is suitable for gradient aggregation scenarios in federated learning; alternatively, fully homomorphic encryption schemes such as BFV or CKKS can be used, which support more complex ciphertext operations, but also have greater computational overhead. It is understood that other schemes can also be used to implement this step, and no limitation is made here.

[0057] In some embodiments, there may be a mismatch between the floating-point precision of the gradient value and the requirements of the homomorphic encryption scheme. To address this, the data processing system performs preprocessing before encryption. For example, if the homomorphic encryption scheme only supports integer operations, the data processing system multiplies the floating-point gradient by a large scaling factor (e.g., 10^6) and rounds it to a fixed-point form before encryption. After decryption, it is divided by the same scaling factor to recover its approximate floating-point value.

[0058] S106. Send the local ciphertext gradient to the aggregation server and receive the global ciphertext gradient from the aggregation server.

[0059] In this context, the aggregation server is a centralized or decentralized coordination node in the federated learning architecture, responsible for collecting and aggregating model update information from all participants; the global ciphertext gradient refers to the final result obtained by the aggregation server after homomorphically aggregating (such as adding) the local ciphertext gradients collected from all participants, and this result is still in ciphertext form.

[0060] Specifically, after encryption, the data processing system sends the local ciphertext gradient to a pre-defined aggregation server address via a secure network channel (such as TLS / SSL). After collecting the local ciphertext gradients from all (or a pre-defined number) participants, the aggregation server uses the properties of homomorphic encryption to directly perform aggregation operations (usually homomorphic addition) on the ciphertext to obtain the global ciphertext gradient. Subsequently, the aggregation server broadcasts or sends this global ciphertext gradient to all participants individually. The data processing system then receives this global ciphertext gradient.

[0061] S107. Perform decryption operation on the global ciphertext gradient based on the local private key to generate the plaintext global gradient, and update the weight parameters of the feature extraction network according to the plaintext global gradient.

[0062] Among them, the local private key is the key paired with the homomorphic encryption public key, which is kept privately by this data processing system and used for decryption; the plaintext global gradient is the gradient value obtained after decrypting the global ciphertext gradient and can be directly used for model updates; the weight parameters refer to the parameters that need to be learned and updated in the feature extraction network.

[0063] Specifically, after receiving the global ciphertext gradient, the data processing system decrypts it using its own local private key. Due to the nature of homomorphic encryption, the decrypted result is equivalent to the sum of the plaintext gradients of all participants. After obtaining this plaintext global gradient, the data processing system uses it as input to the standard gradient descent algorithm (or its variants, such as Adam and RMSProp) to update the weight parameters of the local feature extraction network, thus completing one iteration of federated learning.

[0064] In some embodiments, weight updates can be implemented in several ways: optionally, stochastic gradient descent (SGD) can be used, which involves subtracting the product of the learning rate and the plaintext global gradient from the current weights; alternatively, the Adam optimizer can be used, which additionally maintains the first and second moments of the gradient to achieve adaptive learning rate adjustment, typically resulting in faster convergence. It is understood that other optimization algorithms can also be used to implement this step, and this is not limited here. In some embodiments, there may be scenarios where multiple parties decrypt and aggregate the results using their private keys (e.g., certain multi-party secure computation schemes). In this case, the data processing system participates in a multi-party collaborative decryption protocol. Each party uses its own private key fragment to partially decrypt the global ciphertext gradient and sends the partial decryption results to other parties for combination, ultimately recovering the plaintext global gradient. No single party can decrypt it independently.

[0065] The following provides a more detailed description of the process of the method provided in this implementation. Please refer to [link / reference]. Figure 2 This is another flowchart illustrating the privacy protection method for cross-domain collaboration in this application embodiment.

[0066] S201. Based on the feature extraction network, perform batch forward propagation operations on the samples in the local sample dataset to obtain intermediate activation values ​​corresponding to some samples and store them in a temporary storage area.

[0067] Refer to step S101, which will not be repeated here.

[0068] In some embodiments, the data processing system performs a caching optimization strategy before starting the batch forward propagation operation. Specifically, the data processing system obtains the intersection sample records that have been determined in the historical training tasks and counts the frequency of each sample in the local sample dataset in the intersection sample records. Based on the order of frequency from high to low, it selects a high-priority sample set with a preset number of samples from the local sample dataset. When the capacity of the temporary storage area reaches a preset limit, it retains the intermediate activation values ​​corresponding to the high-priority sample set and deletes the intermediate activation values ​​corresponding to other sample data outside the high-priority sample set.

[0069] Among them, historical training tasks refer to the completed past rounds of federated learning iterations; intersection sample records refer to the list of intersection sample IDs obtained after each intersection calculation, stored in local logs or databases; frequency of occurrence refers to the number of times or proportion of a specific sample ID appearing in all historical intersection records; and high-priority sample set refers to samples that are predicted to be the most likely to become part of the intersection samples again in future training.

[0070] Specifically, before starting a new training round or when data eviction is needed in the cache, the data processing system executes this cache preheating and management logic. The system first accesses the stored historical intersection records and counts the total number of times each local sample ID appears in the historical records. Then, it sorts all local samples in descending order based on the counted frequency. The system selects a preset number of samples (e.g., the number equal to the temporary storage capacity) that rank highly to form a high-priority sample set. During subsequent forward propagation and caching, if the temporary storage is full, the system will prioritize deleting cached items that do not belong to the high-priority sample set. If all cached items belong to the high-priority set, the least frequent item can be deleted.

[0071] In some embodiments, this cache management strategy can be implemented in several ways: Optionally, during batch forward propagation, the intermediate activation values ​​of high-priority sample sets are calculated first and stored in the cache before processing other samples; Optionally, when the cache is full, an eviction process is triggered, scanning the entire cache and removing one or more of the lowest-priority cache items to make room for new items. It is understood that other methods can also be used to implement this step, such as incorporating the temporal locality of samples and introducing a weighted decay frequency statistics method to give higher weight to recent intersection records; this is not limited here.

[0072] In some embodiments, a cold start problem may occur, where the frequency of occurrences cannot be calculated without any historical training records. To address this, the data processing system initially employs a default cache replacement strategy, such as random replacement or first-in-first-out (FIFO). Simultaneously, the system begins recording the intersection results of each round. After several rounds of training, having accumulated sufficient historical data, the system can smoothly switch to a frequency-based priority caching strategy, thereby gradually improving caching efficiency.

[0073] S202. After performing the privacy set intersection protocol with the external computing node, determine the intersection sample set.

[0074] Refer to step S102, which will not be repeated here.

[0075] In some embodiments, the data processing system employs an efficient privacy-preserving set intersection method. Specifically, the system generates a local Bloom filter based on local sample identifiers from the local sample dataset and sends the local Bloom filter to the external computing node; it receives an external Bloom filter generated from the external sample identifiers returned by the external computing node; it maps the local sample identifiers to the external Bloom filter to perform membership queries, determining a candidate intersection sample subset; and it executes a privacy-preserving set intersection protocol on the candidate intersection sample subset and the external computing node to determine the intersection sample set.

[0076] Among them, the Bloom filter is a highly space-efficient probabilistic data structure used to determine whether an element is in a set; the local Bloom filter is a Bloom filter constructed from a set of local sample identifiers; membership query refers to checking whether the corresponding bits are all 1 after calculating the hash function of an element through the Bloom filter; the candidate intersection sample subset refers to the subset of local samples that are judged to be likely to exist in the other set after querying through the Bloom filter.

[0077] Specifically, to reduce the overhead of the expensive standard PSI protocol, the data processing system employs a two-phase intersection method. In the first phase, the system inserts all local sample IDs into an empty Bloom filter, generating a local Bloom filter, which is then sent to the external computing node. Simultaneously, it receives external Bloom filters from the external node. In the second phase, the system iterates through all local sample IDs, querying each one in the received external Bloom filter. Due to the possibility of false positives in Bloom filters (which may incorrectly classify elements not in the set as being in the set), all local sample IDs with a "yes" query result constitute a candidate intersection sample subset. This subset contains all true intersection samples, along with a small number of non-intersection samples. Finally, the system performs a standard, error-free privacy-preserving set intersection protocol only once with the external node on this much smaller candidate intersection sample subset, thus obtaining the final, accurate intersection sample set.

[0078] In some embodiments, the two-phase intersection can be implemented in several ways: Optionally, after exchanging Bloom filters, the parties perform a local query and then use the resulting candidate subset for subsequent standard PSI protocols; alternatively, an encrypted Bloom filter can be constructed to provide higher security during the exchange process. It is understood that other methods can also be used to implement this step, such as using other probabilistic data structures like cuckoo hashes for pre-screening, which is not limited here.

[0079] In some embodiments, inappropriate selection of Bloom filter parameters (number of hash functions k and bit array size m) can lead to an excessively high false positive rate. If the false positive rate is too high, the size of the candidate intersection sample subset will approach the original set, significantly reducing the effectiveness of pre-screening. To address this, the data processing system pre-calculates the optimal values ​​of k and m based on the size n of the local sample set and the expected intersection size using a formula. This minimizes the false positive rate within a given storage space, thereby ensuring the effectiveness of the pre-screening stage.

[0080] S203. Using the identifier of the target sample in the intersection sample set as an index, query the temporary storage area to obtain the storage model version number associated with the corresponding intermediate activation value.

[0081] The identifier of the target sample refers to a specific sample ID in the intersection sample set; the stored model version number refers to the model version number of the feature extraction network when storing the intermediate activation value of the sample. This version number is usually incremented after each global model update.

[0082] Specifically, after determining the set of intersection samples, the data processing system begins processing these samples that need to participate in the computation. For each sample identifier in the set, the data processing system first attempts to check if it exists in the temporary storage area. If it exists, the sample is considered a potential target sample. The data processing system must not only read the intermediate activation value in its cache, but also the metadata stored with that value, especially the storage model version number.

[0083] In some embodiments, version number management can be implemented in several ways: Optionally, the data processing system maintains a global integer counter as the model version number, which is incremented by one each time a global model update in step S211 is performed; alternatively, the data processing system can use a globally unique string (such as a UUID or timestamp) as the model version number. It is understood that other methods can also be used to implement this step, such as using a version number issued by the aggregation server, which is not limited here.

[0084] In some embodiments, metadata in the temporary storage area may be corrupted or lost. In such cases, the data processing system will treat the cached entry as invalid. If a valid storage model version number cannot be obtained during a query, even if the intermediate activation value itself exists, the sample will be considered a cache miss and included in the remaining samples for recalculation to ensure the accuracy of the calculation.

[0085] S204. When the stored model version number and the current model version number of the feature extraction network are inconsistent, the target sample is marked as a sample that needs to be recalculated and is included in the remaining samples to re-execute the forward propagation.

[0086] Here, the current model version number of the feature extraction network refers to the latest global update version number that the local network model has undergone when this step is performed; samples that need to be recalculated are those that are found in the cache but are judged to be invalid due to version mismatch and need to be recalculated completely.

[0087] Specifically, after obtaining the stored model version number retrieved in step S203, the data processing system compares it with the current model version number it maintains. If the two are inconsistent, it indicates that the cached intermediate activation value was calculated based on an older version of the model. If it is directly used for backpropagation of the current new version model, it will lead to gradient calculation errors. Therefore, the data processing system will remove the sample from the target sample list and add its identifier to a list that needs to be recalculated. This list will be subsequently merged with the original remaining samples for processing.

[0088] In some embodiments, the marking and merging can be implemented in several ways: Optionally, the data processing system can maintain a Boolean flag, setting the marked samples to false, and skipping these samples when processing target samples later; Optionally, the data processing system can directly add the identifier of the marked sample to the set of remaining samples for unified processing in step S206. It is understood that other methods can also be used to implement this step, which are not limited here.

[0089] In some embodiments, all cached samples may become invalid due to version inconsistency. This typically occurs after a model update, before the cache has been refreshed by the next round of forward propagation. In response, the data processing system will normally classify all intersection samples as samples requiring recalculation and perform a complete forward and backward propagation. Although this round does not benefit from the cache, the process fills the cache with intermediate activation values ​​calculated by the new version of the model, preparing for efficiency improvements in the next round of training.

[0090] S205. Extract the intermediate activation values ​​corresponding to the target samples in the intersection sample set from the temporary storage area and perform backpropagation to obtain a partial effective gradient.

[0091] Referring to step S103, the specific targets of this step are the actual target samples that have been screened in step S204 and confirmed to have the same model version. The data processing system only performs the cache-based second half of the computation on these samples to obtain a portion of the effective gradients.

[0092] In some embodiments, the data processing system performs a global cache validity check before performing version verification. Specifically, the data processing system obtains the current global iteration round identifier of the feature extraction network; checks the last update round identifier recorded in the metadata of the temporary storage area; and clears the temporary storage area and marks all intersection samples as samples that need to be recalculated when the global iteration round identifier and the last update round identifier do not match.

[0093] The global iteration round identifier is a unique ID that identifies each federated learning iteration, such as an integer that increments from 0; the last update round identifier is a value recorded in the global metadata of the temporary storage area, indicating the training round to which the storage area was last written with data.

[0094] Specifically, at the start of each training round, before performing any cache read operations, the data processing system performs a macro-level cache consistency check. The system obtains the global iteration round identifier for the current training run, maintained by the aggregation server or locally, and reads the last updated round identifier recorded in the temporary storage metadata. If these two identifiers do not match, it means that all data cached in the current temporary storage comes from previous training rounds and is outdated and invalid. In this case, the data processing system directly performs a clear operation, marking the entire temporary storage as invalid or deleting all content, and treating all intersection samples from this round as samples requiring recalculation. This check avoids the overhead of performing version checks on each item.

[0095] In some embodiments, this global check can be implemented in several ways: Optionally, the last updated round identifier can be recorded in the header of the temporary storage area or in a separate metadata file, and this file can be read and compared at the start of each training session; alternatively, the round identifier can be used as part of the cache key, for example, key=(round_id, sample_id), so that when entering a new round, the old cache cannot be retrieved using the new round_id. It is understood that other methods can also be used to implement this step, which are not limited here.

[0096] In some embodiments, a system restart may cause the global iteration round identifier to be lost or rolled back. To address this, the data processing system can synchronize with the aggregation server. At the start of each training round, the local data processing system requests the current official global iteration round identifier from the aggregation server, using this identifier as the basis for all subsequent decisions. This ensures that even if the local state becomes abnormal, a correct and consistent state can be restored through synchronization with the central coordinator.

[0097] S206. Perform forward and backward propagation on the remaining samples in the intersection sample set except for the target sample to obtain the remaining effective gradients, and combine the partial effective gradients to generate an effective gradient set.

[0098] Referring to step S104, the remaining samples in this step include not only the samples that were not hit in the original cache, but also the samples that were marked as needing recalculation in step S204 due to model version inconsistency. The data processing system will perform a full-process calculation on the merged complete remaining sample set to obtain the remaining valid gradients, and combine them with the gradients from step S205.

[0099] S207. Based on the differential privacy budget parameters, determine a noise vector with the same dimension as the effective gradient set.

[0100] Among them, the differential privacy budget parameter (usually denoted by ε) is a value used to quantify the degree of privacy protection. The smaller ε is, the higher the level of privacy protection. The noise vector is a random number vector with the same dimension as the gradient vector, whose elements are sampled from a specific probability distribution (such as a Gaussian distribution or a Laplace distribution).

[0101] Specifically, after generating a valid set of gradients but before encryption, the data processing system introduces a differential privacy mechanism to provide stronger privacy protection. The system determines the statistical properties that the noise vector must satisfy based on a pre-defined differential privacy budget parameter ε and a sensitivity Δf (an upper bound on the gradient norm). For example, when using a Gaussian mechanism, each element of the noise vector is independently sampled from a Gaussian distribution with a mean of 0 and a standard deviation of σ, where σ is related to Δf and ε.

[0102] In some embodiments, the noise vector can be generated in several ways: optionally, the data processing system uses a Laplace mechanism to sample noise from a Laplace distribution, which is suitable for L1 sensitivity; optionally, the data processing system uses a Gaussian mechanism to sample noise from a Gaussian distribution, which is suitable for L2 sensitivity and has better properties when combined. It is understood that other mechanisms can also be used to implement this step, and no limitation is made here.

[0103] In some embodiments, there is a problem of how to accurately estimate the gradient sensitivity Δf, as inaccurate estimation can affect the effectiveness of privacy protection. To address this, the data processing system employs gradient clipping techniques. After calculating the effective gradient, the system calculates its L2 norm. If the norm exceeds a preset threshold C, the gradient vector is scaled proportionally until its norm is exactly equal to C. In this way, the gradient sensitivity is limited to within C, making noise calibration more accurate and reliable.

[0104] S208. Based on the effective gradient set and the noise vector, generate a perturbation gradient that meets the differential privacy protection requirements, and use the perturbation gradient as the data to be encrypted to perform the encryption operation.

[0105] The perturbation gradient refers to the result obtained by adding the original set of effective gradients to the noise vector generated in step S207. This gradient statistically preserves the information of a single sample.

[0106] Specifically, the data processing system performs vector addition on the noise vector generated in step S207 and the effective gradient set generated in step S206, that is, each gradient component is added to its corresponding noise component to obtain the final perturbed gradient. This perturbed gradient retains the main direction and magnitude information of the original gradient, which is sufficient to support model convergence, but the noise it contains makes it difficult for attackers to accurately deduce the contribution of any individual training sample. Subsequently, this perturbed gradient is used as input for homomorphic encryption in step S209.

[0107] In some embodiments, this step can be implemented in several ways: Optionally, the data processing system can directly perform gradient calculation, noise generation, and addition operations on the GPU to reduce the overhead of data transfer between different devices; alternatively, the data processing system can also perform noise generation and addition operations on the CPU, which is feasible when the noise vector dimension is low. It is understood that other methods can also be used to implement this step, which are not limited here.

[0108] S209. Perform encryption operations on the effective gradient set based on the homomorphic encryption public key to generate local ciphertext gradients.

[0109] Referring to step S105, the main difference between this step and S105 is that the encrypted object is no longer the original set of valid gradients, but the perturbed gradients obtained after processing in step S208.

[0110] S210. Send the local ciphertext gradient to the aggregation server and receive the global ciphertext gradient from the aggregation server.

[0111] Refer to step S106, which will not be repeated here.

[0112] S211. Perform a decryption operation on the global ciphertext gradient based on the local private key to generate a plaintext global gradient, and update the weight parameters of the feature extraction network according to the plaintext global gradient.

[0113] Refer to step S107, which will not be repeated here.

[0114] In some embodiments, the data processing system dynamically adjusts the intensity of differential privacy noise. Specifically, the data processing system obtains the cumulative training epochs of the current federated learning task; calculates the privacy budget decay coefficient corresponding to the current epoch based on a preset decay function and the cumulative training epochs; and adjusts the variance parameter of the generated noise vector based on the privacy budget decay coefficient.

[0115] Among them, the cumulative training rounds refer to the total number of iterations completed from the start of training to the present; the preset decay function is a function that maps the cumulative training rounds to the decay coefficient, such as the exponential decay function; the privacy budget decay coefficient is a factor between 0 and 1 used to adjust the basic privacy budget; the variance parameter is a key parameter that determines the magnitude of Gaussian noise, and the larger the variance, the greater the noise.

[0116] Specifically, to achieve a better balance between privacy protection and model performance, the data processing system employs a dynamic privacy budget strategy. In the t-th training round, the system first obtains the cumulative training rounds t. Then, based on a preset decay function, such as decay_factor = exp(-c*t) (where c is the decay rate), it calculates the privacy budget decay coefficient for the current round. The system uses this coefficient to adjust the base privacy budget ε, obtaining the effective privacy budget ε_t = ε_base / decay_factor for the current round. Since the noise variance is proportional to 1 / ε, this means that as the training rounds t increase, the decay coefficient decreases, the effective privacy budget ε_t increases, and thus the noise variance decreases. This results in stronger privacy protection during the early stages of training when noise is higher, and reduced noise during the later stages of training, which helps the model converge more accurately.

[0117] In some embodiments, the decay function can be designed in several ways: optionally, exponential decay can be used, as described above; optionally, piecewise constant decay can be used, i.e., different fixed privacy budgets are used in specific phases of training (e.g., the first 10 epochs, epochs 10-50, and after epoch 50). It is understood that this step can also be implemented using other functional forms, such as linear decay or cosine annealing decay, which are not limited here.

[0118] In some embodiments, there is a risk of exceeding the total privacy budget. A key property of differential privacy is combinability, meaning that multiple queries accumulate the total privacy budget. Unrestricted training can cause the total privacy budget to approach infinity, negating the purpose of privacy protection. To address this, the data processing system pre-defines a total training epoch T and a total privacy budget ε_total. Then, the system designs a decay strategy to ensure that the sum of the privacy budgets across all epochs (or the total budget calculated using advanced combinatorics) does not exceed ε_total. When training reaches epoch T, training stops regardless of whether the model converges, strictly guaranteeing the overall privacy commitment.

[0119] In this embodiment, by adopting a technical solution that parallelizes the forward propagation computation and the privacy set intersection process, and designs an intermediate result caching and reuse mechanism, the data processing system can simultaneously utilize local computing resources to preprocess data when performing communication-intensive privacy intersection tasks. This effectively solves the problem of idle computing resources caused by waiting for communication in the traditional serial federated learning process, thereby reducing end-to-end training latency and improving overall data processing efficiency.

[0120] The data processing system in the embodiments of this invention is described below from a hardware processing perspective. Please refer to [link / reference needed]. Figure 3 This is a schematic diagram of the physical device structure of a data processing system in an embodiment of this application.

[0121] It should be noted that, Figure 3 The structure of the data processing system shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of the present invention.

[0122] like Figure 3 As shown, the data processing system includes a CPU 301, which can perform various appropriate actions and processes according to a program stored in ROM 302 or a program loaded from storage section 308 into RAM 303, such as executing the methods described in the above embodiments. RAM 303 also stores various programs and data required for system operation. The CPU 301, ROM 302, and RAM 303 are interconnected via bus 304. I / O interface 305 is also connected to bus 304.

[0123] The following components are connected to I / O interface 305: input section 306 including audio input devices, push-button switches, etc.; output section 307 including liquid crystal display (LCD) and audio output devices, indicator lights, etc.; storage section 308 including hard disks, etc.; and communication section 309 including network interface cards such as LAN (Local Area Network) cards, modems, etc. Communication section 309 performs communication processing via a network such as the Internet. Drive 310 is also connected to I / O interface 305 as needed. Removable media 311, such as disks, optical disks, magneto-optical disks, semiconductor memories, etc., are installed on drive 310 as needed so that computer programs read from them can be installed into storage section 308 as needed.

[0124] In particular, according to embodiments of the present invention, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present invention include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing computer programs for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 309, and / or installed from removable medium 311. When the computer program is executed by CPU 301, it performs the various functions defined in the present invention.

[0125] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. Each block in a flowchart or block diagram may represent a module, program segment, or portion of code, which contains one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those shown in the drawings.

[0126] Specifically, the data processing system of this embodiment includes a processor and a memory. The memory stores a computer program. When the computer program is executed by the processor, it implements the cross-domain collaborative privacy protection method provided in the above embodiment.

[0127] In another aspect, the present invention also provides a computer-readable storage medium, which may be included in the data processing system described in the above embodiments; or it may exist independently and not assembled into the data processing system. The storage medium carries one or more computer programs that, when executed by a processor of the data processing system, enable the data processing system to implement the cross-domain collaborative privacy protection method provided in the above embodiments.

[0128] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit it. Although this application 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. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of this application.

[0129] As used in the above embodiments, depending on the context, the term "when..." can be interpreted as meaning "if...", "after...", "in response to determining...", or "in response to detecting...". Similarly, depending on the context, the phrase "when determining..." or "if (the stated condition or event) is interpreted as meaning "if determining...", "in response to determining...", "when (the stated condition or event) is detected", or "in response to detecting (the stated condition or event)".

Claims

1. A privacy protection method for cross-domain collaboration, characterized in that, Applied to a data processing system, the method includes: Based on the feature extraction network, the samples in the local sample dataset are subjected to batch forward propagation operations to obtain intermediate activation values ​​corresponding to some samples and store them in a temporary storage area. After performing a privacy set intersection protocol with external computing nodes, the intersection sample set is determined; Extract intermediate activation values ​​corresponding to the target samples in the intersection sample set from the temporary storage area and perform backpropagation to obtain a portion of the effective gradients; Forward and backward propagation are performed on the remaining samples in the intersection sample set excluding the target sample to obtain the remaining effective gradients, and the remaining effective gradients are combined to generate an effective gradient set. Based on the homomorphic encryption public key, an encryption operation is performed on the effective gradient set to generate a local ciphertext gradient; The local ciphertext gradient is sent to the aggregation server, and the global ciphertext gradient is received from the aggregation server. Decryption is performed on the global ciphertext gradient using the local private key to generate the plaintext global gradient, and the weight parameters of the feature extraction network are updated based on the plaintext global gradient.

2. The method according to claim 1, characterized in that, Before the step of performing batch forward propagation operations on samples in the local sample dataset based on the feature extraction network to obtain intermediate activation values ​​corresponding to a portion of the samples and storing them in a temporary storage area, the method further includes: Obtain the intersection sample records that have been determined in the historical training tasks, and count the frequency of each sample in the local sample dataset in the intersection sample records; Based on the order of occurrence from high to low, a high-priority sample set with a preset number of samples is obtained from the local sample dataset; When the capacity of the temporary storage area reaches the preset upper limit, the intermediate activation values ​​corresponding to the high-priority sample set are retained, and the intermediate activation values ​​corresponding to other sample data outside the high-priority sample set are deleted.

3. The method according to claim 1, characterized in that, The step of determining the intersection sample set after performing a privacy set intersection protocol with an external computing node specifically includes: A local Bloom filter is generated based on the local sample identifiers of the local sample dataset, and the local Bloom filter is sent to the external computing node. An external Bloom filter is generated by receiving the external sample identifier returned by the external computing node; The local sample identifier is mapped to the external Bloom filter to perform a membership query, thereby determining a subset of candidate intersection samples. A privacy set intersection protocol is executed on the candidate intersection sample subset and the external computing node to determine the intersection sample set.

4. The method according to claim 1, characterized in that, Before the step of extracting intermediate activation values ​​corresponding to the target samples in the intersection sample set from the temporary storage area and performing backpropagation to obtain partial effective gradients, the method further includes: Using the identifier of the target sample in the intersection sample set as an index, query the temporary storage area to obtain the storage model version number associated with the corresponding intermediate activation value; When the storage model version number and the current model version number of the feature extraction network are inconsistent, the target sample is marked as a sample that needs to be recalculated and is included in the remaining samples to re-perform forward propagation.

5. The method according to claim 4, characterized in that, Before the step of querying the temporary storage area using the identifier of the target sample in the intersection sample set as an index to obtain the storage model version number associated with the corresponding intermediate activation value, the method further includes: Obtain the current global iteration round identifier of the feature extraction network; Check the last update round identifier recorded in the metadata of the temporary storage area; When the global iteration round identifier and the last update round identifier do not match, the temporary storage area is cleared, and all the intersection samples are marked as samples that need to be recalculated.

6. The method according to claim 1, characterized in that, Before the step of performing encryption operations on the effective gradient set based on the homomorphic encryption public key to generate local ciphertext gradients, the method further includes: Based on the differential privacy budget parameters, a noise vector with the same dimension as the effective gradient set is determined; Based on the set of valid gradients and the noise vector, a perturbation gradient that meets the differential privacy protection requirements is generated, and the perturbation gradient is used as the data to be encrypted to perform the encryption operation.

7. The method according to claim 6, characterized in that, Prior to the step of determining a noise vector with the same dimension as the effective gradient set based on the differential privacy budget parameters, the method further includes: Obtain the cumulative training rounds of the current federated learning task, and calculate the privacy budget decay coefficient corresponding to the current round based on the preset decay function and the cumulative training rounds; The variance parameter of the noise vector is adjusted based on the privacy budget attenuation coefficient.

8. A data processing system, characterized in that, The data processing system includes: one or more processors and a memory; the memory is coupled to the one or more processors, the memory is used to store computer program code, the computer program code including computer instructions, and the one or more processors call the computer instructions to cause the data processing system to perform the method as described in any one of claims 1-7.

9. A computer-readable storage medium comprising instructions, characterized in that, When the instructions are executed on the data processing system, the data processing system performs the method as described in any one of claims 1-7.

10. A computer program product, characterized in that, When the computer program product is run on a data processing system, the data processing system performs the method as described in any one of claims 1-7.

Images