Privacy calculation dynamic strategy selection method and device based on data sensitivity identification

Abstract

The invention provides a privacy calculation dynamic strategy selection method and device based on data sensitivity identification. The method comprises the following steps: acquiring a privacy computing task request, and analyzing to obtain a target data set and a corresponding operation type; performing sensitivity identification on each field in the target data set to obtain a sensitivity level label corresponding to each field; retrieving a candidate privacy protection strategy set from a preset strategy mapping relation; for the candidate privacy protection strategy set, calculating resource consumption parameters and privacy budget occupation parameters of all strategies are evaluated; performing operator-level splitting and arrangement on the privacy computing task to generate a task scheduling plan; and if it is detected that the resource threshold value or the budget threshold value is triggered, re-executing the step of retrieving the candidate privacy protection strategy set to the step of generating the task scheduling plan based on the resource occupation data and the usage measurement data so as to adjust the target privacy protection strategy. According to the application, accurate identification of sensitivity, on-demand switching of privacy protocols and adaptive balance of resources and budget can be realized.

Description

Technical Field

[0001] This application relates to the field of data security technology, and in particular to a method and apparatus for dynamic selection of privacy computing strategies based on data sensitivity identification. Background Technology

[0002] As data becomes a key national production factor, the demand for cross-domain data collaborative analysis is increasing across various industries. This is particularly true in the power industry, where the large-scale, real-time collection of data on power generation, load curves, equipment status, and user-side energy consumption is growing rapidly. While releasing the value of power data, it is crucial to meet the security requirements of "raw data not leaving the domain and data being usable but not visible." Therefore, building a secure data element circulation mechanism for multi-party collaboration, while maintaining high data utilization and ensuring power data privacy and security, has become a pressing technical challenge for the industry.

[0003] Existing privacy computing solutions mainly revolve around single or fixed combinations of protocols such as differential privacy, multi-party secure computation, homomorphic encryption, and secret sharing: (1) Differential privacy protects query results by superimposing random noise, but for highly sensitive fields, the noise amplitude needs to be increased, which will reduce the accuracy of the results; (2) Multi-party secure computation and secret sharing can be computed after splitting the data among the participants, but the process is complex and has high requirements for network synchronization; (3) Homomorphic encryption supports direct computation on ciphertext and can retain accuracy, but encryption, decryption and homomorphic computation are time-consuming; (4) In order to reduce complexity, some platforms only statically configure privacy protocols according to task type and do not distinguish the sensitivity differences of different fields.

[0004] Existing technologies still suffer from the following problems: Single-strategy or static combination strategies cannot balance the sensitivity of different fields with the computational load of tasks. High-sensitivity data may be at risk of leakage due to insufficient protection, while low-sensitivity data may waste resources due to excessive encryption. Existing solutions lack automatic sensitivity identification mechanisms at the field level, requiring manual configuration or unified rules, making it difficult to adapt to dynamically changing multi-source heterogeneous power data. Privacy-preserving computing tasks lack real-time feedback and control of resource consumption and budget usage during execution, and cannot adjust encryption protocols or noise parameters in real time according to the running status, resulting in a lack of coordination between computational performance and privacy budget control. Task scheduling is usually performed at the job level, lacking operator-level splitting and cross-protocol hybrid orchestration capabilities, and cannot meet the need for differentiated privacy protection for different fields and stages in the same computing process. Summary of the Invention

[0005] In view of this, embodiments of this application provide a method and apparatus for dynamic selection of privacy computing strategies based on data sensitivity identification, in order to solve the problems of single protection strategies, coarse sensitivity identification, and inability to dynamically coordinate and schedule resources and budgets in the prior art.

[0006] A first aspect of this application provides a method for dynamic privacy computing strategy selection based on data sensitivity identification, comprising: acquiring a privacy computing task request to be executed, parsing to obtain a target data set and corresponding operation type; performing sensitivity identification on each field in the target data set to obtain sensitivity level labels corresponding to each field; retrieving a set of candidate privacy protection strategies from a preset strategy mapping relationship according to the operation type and sensitivity level labels; evaluating the computational resource consumption parameters and privacy budget occupancy parameters of each strategy for the candidate privacy protection strategy set, and determining the target privacy protection strategy according to a predetermined scoring rule, generating a strategy descriptor corresponding to the target privacy protection strategy; and selecting a privacy computing task based on the strategy descriptor. The process involves operator-level splitting and orchestration to generate a task scheduling plan, which indicates the sequence of privacy computation operators and their scheduling order. The central node distributes the task scheduling plan and keys or shared parameters matching the target privacy protection strategy to its affiliated computing nodes, and the computing nodes execute the privacy computation operator sequence in the scheduled order. Resource usage data and usage measurement data reported by the computing nodes are collected. If a resource threshold or budget threshold is triggered, the process of retrieving the candidate privacy protection strategy set and generating the task scheduling plan is re-executed based on the resource usage data and usage measurement data to adjust the target privacy protection strategy. After the privacy computation operator sequence is completed, the privacy computation result is returned to the caller to complete the privacy computation task.

[0007] A second aspect of this application provides a privacy computing dynamic strategy selection device based on data sensitivity identification, comprising: a parsing module, configured to acquire a privacy computing task request to be executed, and parse it to obtain a target data set and corresponding operation type; an identification module, configured to perform sensitivity identification on each field in the target data set to obtain a sensitivity level label corresponding to each field; a retrieval module, configured to retrieve a set of candidate privacy protection strategies from a preset strategy mapping relationship according to the operation type and sensitivity level label; an evaluation module, configured to evaluate the computational resource consumption parameters and privacy budget occupancy parameters of each strategy for the set of candidate privacy protection strategies, and determine the target privacy protection strategy according to a predetermined scoring rule, and generate a strategy descriptor corresponding to the target privacy protection strategy; and a generation module, configured to, based on the strategy descriptor, ... The privacy computation task is split and orchestrated at the operator level to generate a task scheduling plan, which indicates the sequence of privacy computation operators and their scheduling order. A distribution module distributes the task scheduling plan and keys or shared parameters matching the target privacy protection strategy to the compute nodes through the central node, and executes the privacy computation operator sequence in the scheduled order on the compute nodes. An adjustment module collects resource usage data and usage measurement data reported by the compute nodes. If a resource threshold or budget threshold is triggered, the step of retrieving the candidate privacy protection strategy set to generate the task scheduling plan is re-executed based on the resource usage data and usage measurement data to adjust the target privacy protection strategy. A return module returns the privacy computation results to the caller after the privacy computation operator sequence has been executed, completing the privacy computation task.

[0008] A third aspect of this application provides an electronic device, 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 implement the steps of the above-described method.

[0009] A fourth aspect of this application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the above-described method.

[0010] The above-described technical solutions adopted in the embodiments of this application can achieve the following beneficial effects:

[0011] By acquiring the privacy-preserving computation task request to be executed, the target data set and corresponding operation type are parsed to obtain them; sensitivity identification is performed on each field in the target data set to obtain the sensitivity level label for each field; based on the operation type and sensitivity level label, a set of candidate privacy protection strategies is retrieved from a preset policy mapping relationship; for the set of candidate privacy protection strategies, the computational resource consumption parameters and privacy budget occupancy parameters of each strategy are evaluated, and the target privacy protection strategy is determined according to a predetermined scoring rule, generating a policy descriptor corresponding to the target privacy protection strategy; based on the policy descriptor, the privacy computation task is split and orchestrated at the operator level to generate a task scheduling plan. The task scheduling plan specifies the sequence and order of privacy computation operators. The central node distributes the task scheduling plan and keys or shared parameters matching the target privacy protection strategy to its affiliated computing nodes, which then execute the privacy computation operator sequence in the scheduled order. Resource usage and consumption data reported by the computing nodes are collected. If a resource threshold or budget threshold is triggered, the step of retrieving the candidate privacy protection strategy set to generate the task scheduling plan is re-executed based on the resource usage and consumption data to adjust the target privacy protection strategy. After the privacy computation operator sequence is completed, the privacy computation result is returned to the caller to complete the privacy computation task. This application enables accurate sensitivity identification, on-demand switching of privacy protocols, and adaptive balancing of resources and budget. Attached Figure Description

[0012] To more clearly illustrate the technical solutions in the embodiments of this application, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0013] Figure 1 This is a flowchart illustrating the privacy computing dynamic strategy selection method based on data sensitivity identification provided in an embodiment of this application.

[0014] Figure 2 This is a schematic diagram of the structure of the privacy computing dynamic strategy selection device based on data sensitivity identification provided in the embodiments of this application;

[0015] Figure 3 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Detailed Implementation

[0016] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods have been omitted so as not to obscure the description of this application with unnecessary detail.

[0017] Currently, data-intensive industries such as power generally employ fixed or single-combination protocols such as differential privacy, multi-party secure computation, homomorphic encryption, or secret sharing to perform cross-domain collaborative computing. Because these protocols differ significantly in terms of protection strength, computational complexity, and network synchronization requirements, existing systems typically statically select protocols based on task type or uniformly encrypt all data, lacking the ability to identify and differentiate between field-level sensitivity differences.

[0018] Fixed strategies have two drawbacks: firstly, applying only weak protection to highly sensitive fields can easily lead to leakage risks; secondly, uniformly using heavy encryption for low-sensitivity fields can result in wasted computing power and budget. Furthermore, existing privacy computing platforms lack runtime resource-budget feedback and control, making it impossible to dynamically switch protocols or adjust noise based on load and budget during computation, thus hindering the real-time balance between privacy strength and performance / cost.

[0019] This application proposes a dynamic policy selection method for privacy computing based on data sensitivity identification: First, feature vectors are constructed using field metadata, and sensitivity levels are inferred locally on each computing node; then, candidate privacy protection policies are retrieved in a two-layer mapping structure according to operation type, sensitivity level, and real-time resource-budget status, and the target policy is determined and a policy descriptor is generated using a reinforcement learning-driven multi-objective scoring model; then, the operator scheduling module performs operator-level splitting and hybrid orchestration of tasks, and the scheduling plan and corresponding key / shared parameters are issued to the computing nodes for execution through the central node; if resource or budget thresholds are triggered during execution, the central node re-evaluates the policy and incrementally re-arranges the unexecuted segments to achieve adaptive policy adjustment.

[0020] This application's solution can accurately identify the sensitivity of heterogeneous multi-source data and switch differential privacy, homomorphic encryption, secret sharing, and other protocols as needed within the same computing process. At the same time, through real-time feedback and adjustment of resources and budget, it can maintain a dynamic balance between the strength of privacy protection and computing performance and cost, thereby improving privacy security, computing power utilization, and budget control accuracy.

[0021] The technical solution of this application will now be described in detail with reference to the accompanying drawings and specific embodiments.

[0022] Figure 1This is a flowchart illustrating the privacy computing dynamic strategy selection method based on data sensitivity identification provided in an embodiment of this application. Figure 1 As shown, the privacy computing dynamic strategy selection method based on data sensitivity identification can specifically include:

[0023] S101, Obtain the privacy computing task request to be executed, and parse it to obtain the target data set and the corresponding operation type;

[0024] S102, Perform sensitivity identification on each field in the target dataset to obtain the sensitivity level label corresponding to each field;

[0025] S103, based on the operation type and sensitivity level label, retrieve the set of candidate privacy protection strategies from the preset strategy mapping relationship;

[0026] S104. For the set of candidate privacy protection strategies, evaluate the computational resource consumption parameters and privacy budget usage parameters of each strategy, determine the target privacy protection strategy according to the predetermined scoring rules, and generate a strategy descriptor corresponding to the target privacy protection strategy.

[0027] S105, Based on the policy descriptor, perform operator-level splitting and orchestration of the privacy computing task to generate a task scheduling plan, wherein the task scheduling plan indicates the sequence of privacy computing operators and the scheduling order;

[0028] S106, The central node distributes the task scheduling plan and the key or shared parameters that match the target privacy protection strategy to the computing nodes, and executes the privacy computing operator sequence in the scheduling order on the computing nodes;

[0029] S107: Collect resource usage data and usage measurement data reported by computing nodes. If the resource threshold or budget threshold is detected to be triggered, re-execute the step of retrieving the set of candidate privacy protection policies to generate a task scheduling plan based on the resource usage data and usage measurement data, so as to adjust the target privacy protection policy.

[0030] S108: After the privacy computation operator sequence is completed, the privacy computation result is returned to the caller to complete the privacy computation task.

[0031] In some embodiments, sensitivity identification is performed on each field in the target dataset to obtain a sensitivity level label corresponding to each field, including:

[0032] Obtain the metadata associated with the field, and perform semantic parsing, statistical distribution analysis and cross-domain access trajectory hash encoding in sequence based on the metadata to generate a field feature vector that integrates semantic features, statistical features and time series features;

[0033] The field feature vector is input into a multi-task sensitivity classification model that is deployed locally on each computing node and jointly trained by the central node using a secret sharing protocol. The multi-task sensitivity classification model uses a lightweight multi-layer self-attention encoder and shares a set of interpretable attention weights.

[0034] Sensitivity level labels corresponding to fields are inferred locally on each computing node, and these sensitivity level labels are written to the metadata repository for retrieval and use in policy mapping relationships.

[0035] Specifically, the following embodiments will provide a detailed explanation of the step of "performing sensitivity identification on each field in the target data set" in the context of power data governance. The specific implementation may include the following:

[0036] First, metadata collection and preprocessing can include the following:

[0037] In the task initialization process issued by the central node, the data management module first calls the metadata synchronization function to read field-level metadata from the accessed power data sources (such as real-time load curve tables, electricity billing tables, user profile tables, etc.). The metadata includes at least the field name, field type, physical storage path, source system, generation period, value range, data lineage, and cross-domain access history. After collection, the data management module generates a unique key by field name-version number, writes the metadata to the metadata repository, and assigns a status tag to be identified for each field in the repository.

[0038] Next, the construction of field feature vectors can include the following:

[0039] 1. Semantic Parsing: A power industry-specific dictionary and rule base are loaded locally on each computing node to perform word segmentation and part-of-speech tagging on field names and source descriptions. Taking "load_curve_15min" as an example, the parsing process yields three semantic units: "load," "curve," and "15min." Then, through synonym mapping and normalization, "load" is uniformly mapped to "load." Finally, a semantic vector fragment is output.

[0040] 2. Statistical Distribution Analysis: Perform type-aware statistics on samples of this field within the last seven days. If the field type is numeric, calculate indicators such as range, skewness, kurtosis, and monotonicity distribution; if the field type is string, calculate indicators such as unique value count, entropy, and average length. All statistical indicators are concatenated into statistical vector fragments in a fixed order.

[0041] 3. Cross-domain access trajectory hash encoding: The access log interface exposed by the communication management module is called to extract cross-domain access sequences (accessor identifier, timestamp, operation type) from the past month. For each sequence, an improved time sliding window hash algorithm is used to generate a fixed-length hash fragment, which is then concatenated in chronological order and compressed using SHA-256 to obtain a time-series vector fragment.

[0042] 4. Vector concatenation: Semantic vector fragments, statistical vector fragments, and temporal vector fragments are concatenated and standardized in the order of "semantic-statistical-temporal" to form a field feature vector that integrates semantic features, statistical features, and temporal features. The vector length is between 64 and 128, and can be automatically expanded or truncated according to the specific model configuration.

[0043] Then, the deployment and inference of the multi-task sensitivity classification model can include the following:

[0044] 1. Model Training Overview: The central node triggers the federated training task within the model update window. Each computing node loads locally labeled samples, splits gradients using a secret sharing protocol, and aggregates parameters using the master-slave scheduling function of the operator scheduling module. The model structure is a lightweight multi-layer self-attention encoder. The first layer is used to capture semantic dependencies, the middle layers are used for statistical and temporal pattern interaction, and the last layer shares a set of interpretable attention weights and outputs four types of sensitivity probability distributions.

[0045] 2. Model Deployment: After training is complete, the central node generates the model fingerprint and distributes it to each computing node. Each node loads the corresponding model instance within a trusted execution environment, ensuring that the weight file is not leaked.

[0046] 3. Local Inference: Once the field feature vector is ready, the operator scheduling module triggers the inference subtask, feeding the vector into the model to obtain a four-dimensional probability vector, corresponding to labels L0 (public), L1 (general), L2 (sensitive), and L3 (confidential). Nodes determine the final sensitivity level label locally based on the principle of maximum probability, while simultaneously recording attention scores to support later auditing and tracing.

[0047] Finally, label writing and subsequent calls can include the following:

[0048] After inference is complete, the compute node submits the following entries to the metadata repository through the data management module: field unique key, sensitivity level label, confidence score, model fingerprint, and inference timestamp. Upon receiving the write request, the repository automatically updates the status to be identified to the identified status and triggers a cache refresh of the policy mapping engine. Subsequently, when the central node parses the privacy computing task, it can retrieve the set of candidate privacy protection policies based on the latest sensitivity level label, completing dynamic policy selection and task orchestration.

[0049] Through the above specific embodiments, those skilled in the art can clearly reproduce each step of field-level sensitivity identification and complete accurate sensitivity labeling in power data scenarios, providing a reliable foundation for subsequent dynamic strategy selection for privacy computing.

[0050] In some embodiments, a set of candidate privacy protection policies is retrieved from a preset policy mapping relationship based on the operation type and sensitivity level label, including:

[0051] Construct a multi-dimensional composite key that includes operation type identifier, sensitivity level label, administrative domain identifier where the data is located, and real-time resource load threshold;

[0052] Parallel retrieval is performed in the two-layer mapping structure maintained by the policy mapping engine using multi-dimensional composite keys. The two-layer mapping structure consists of a high-dimensional index table based on hash prefix compression and a directed acyclic policy graph divided according to policy priority.

[0053] In the directed acyclic policy graph, traverse along the in-degree edges that match the operation type identifier and sensitivity level label to the leaf node, and collect the set of privacy protection policies identified by the reached leaf node as the candidate privacy protection policy set.

[0054] Specifically, the following embodiments will detail the step of "retrieving a set of candidate privacy protection strategies based on operation type and sensitivity level labels" in the context of cross-domain joint modeling of power data. The specific implementation may include the following:

[0055] First, the construction of multidimensional composite keys can include the following:

[0056] When the central node resolves to the "Horizontal Logistic Regression Joint Modeling" task, and the field sensitivity level label is L2, the administrative region identifier of the data is "Inner Mongolia Autonomous Region," and the monitoring and alarm module reports real-time CPU utilization of 0.68, GPU utilization of 0.52, and network occupancy of 0.43, the policy mapping engine first concatenates the operation type identifier (HTLR), sensitivity level label (L2), administrative region identifier (NMG), and resource load threshold vector (0.68|0.52|0.43) in a fixed order. Then, it calculates a digest using SHA-256 on the concatenated result, and extracts the first 64 bits as a hash prefix index code, ultimately forming a multi-dimensional composite key in the form of "HTLR-L2-NMG-685243-64." This key not only carries business and data security semantics but also real-time resource pressure information, laying the foundation for subsequent policy optimization.

[0057] Furthermore, the two-layer mapping structure design can include the following:

[0058] 1. Hash prefix compressed high-dimensional index table

[0059] The policy mapping engine maintains a prefix-compressed index table based on a modified Burst-Trie structure. The table entry key is the hash prefix index code of the multi-dimensional composite key mentioned above, and the table entry value is a set of pointers to the root node of the directed acyclic policy graph. Once multiple composite keys share a long prefix, the index table is automatically folded into a single-node storage, compressing redundancy and improving retrieval speed and memory utilization.

[0060] 2. Directed Acyclic Strategy Graph

[0061] The strategy diagram is hierarchically divided from top to bottom according to "data security priority." The root node is aggregated by operation type, the intermediate nodes are further subdivided by sensitivity level, the child nodes are further subdivided into resource usage ranges and administrative domain compliance constraints, until the leaf nodes store privacy protection policy identifiers. The edges in the diagram have weights to indicate the policy priority order and switchable paths.

[0062] Furthermore, parallel retrieval and strategy set generation can include the following:

[0063] 1. Parallel retrieval trigger

[0064] Upon receiving the multidimensional key combination, the strategy mapping engine initiates a four-thread parallel retrieval: two threads are responsible for locating the set of pointers to the root node within the index table, while the other two threads preload the corresponding subgraph to reduce subsequent traversal latency.

[0065] 2. Graph traversal convergence

[0066] After the retrieval is completed, the main thread uses the operation type identifier and sensitivity level label as matching constraints, and traverses from the root node along the matching in-degree edges in a depth-first manner to the leaf nodes; during the traversal, the resource load threshold vector is read in real time, and if the edge weight corresponding to the strategy exceeds the current resource threshold, the branch is pruned.

[0067] 3. Strategy set output

[0068] When the traversal reaches a leaf node, the policy identifiers of all leaf nodes that satisfy the constraints and have not been pruned are collected to form a candidate privacy protection policy set. This set, along with the edge weights of the traversal path, is written to a temporary cache. Subsequently, the policy mapping engine outputs the candidate policy set and its priority metadata to the resource and budget evaluation module, providing input for subsequent scoring and target policy determination.

[0069] Through the above embodiments, those skilled in the art can quickly locate a set of privacy protection strategies that match business needs, data sensitivity, and real-time resource status within the power data element secure circulation platform, laying an efficient and scalable retrieval foundation for dynamic strategy selection.

[0070] In some embodiments, the computational resource consumption parameters and privacy budget occupancy parameters of each strategy are evaluated, and a target privacy protection strategy is determined according to a predetermined scoring rule. A strategy descriptor corresponding to the target privacy protection strategy is generated, including:

[0071] By calling real-time node resource telemetry data and combining the operator execution configuration of candidate privacy protection strategies, an adaptive resource prediction model based on graph convolutional networks is used to output the computational resource consumption vector corresponding to each candidate privacy protection strategy.

[0072] The remaining privacy budget value is used to calculate the budget occupancy vector corresponding to each candidate privacy protection strategy based on the preset privacy budget occupancy model.

[0073] Based on the computational resource consumption vector and budget usage vector, a reinforcement learning-driven multi-objective scoring function is invoked to generate a comprehensive score list, and the highest-scoring strategy is selected as the target privacy protection strategy according to the comprehensive score list.

[0074] After selecting the target privacy protection policy, a policy descriptor is constructed, which includes a policy identifier, protocol parameter pointers, key index, budget deduction identifier, and operator sequence encoding.

[0075] Specifically, the following embodiments use a cross-domain joint modeling task as an example to illustrate the implementation details of the "evaluating candidate strategies and determining the target privacy protection strategy" step, focusing on the technical points of public resource prediction, budget estimation and multi-objective scoring.

[0076] First, real-time resource telemetry and feature construction can include the following:

[0077] The central node, through its monitoring and alarm module, retrieves the CPU utilization, GPU utilization, memory usage, network throughput, and I / O wait rate of each computing node every 5 seconds, forming a resource state vector of length 5. To capture the topological dependencies between nodes, the operator scheduling module treats all computing nodes as vertices in a graph structure, with vertex attributes representing the resource state vector and edge attributes representing the average network latency between nodes. This dynamic graph serves as the input for the subsequent resource prediction model.

[0078] Furthermore, the adaptive resource prediction model may include the following:

[0079] 1. Model Structure

[0080] The resource prediction model uses a two-layer graph convolutional network (GraphConvNet). The first layer aggregates the resource status of neighboring vertices, and the second layer introduces a temporal convolutional kernel to extract temporal features of the status over the past N periods, outputting the probability distribution of resource occupancy for each node within the future Δt window.

[0081] 2. Training and Deployment

[0082] The model is trained offline using node telemetry logs and operator execution records from the past month. After federated training is completed at the central node through secret sharing of encrypted gradients, the weight files are distributed to the inference engines of each computing node.

[0083] Furthermore, the generation of computational resource consumption vectors can include the following:

[0084] The policy mapping engine traverses the set of candidate privacy protection policies, reads the operator configuration for each policy, including the required operator type, parallelism factor, memory threshold, and encryption algorithm complexity level. Then, it calls the resource prediction model to infer the upper bound of available resources for each node, and weights the policy configuration and prediction results operator by operator to obtain a computational resource consumption vector with dimensions (CPU, GPU, Mem, Net, I / O), which is recorded in the policy evaluation cache.

[0085] Furthermore, the privacy budget occupancy vector computation may include the following:

[0086] The usage measurement mechanism returns the remaining privacy budget value ε_rem and the budget hierarchical vector. The privacy budget occupancy model calculates the budget consumption Δε at the central node and forms the budget occupancy vector (Δε, r, s) based on the required protocol of the policy (differential privacy, homomorphic encryption, secret sharing), noise amplitude λ, ciphertext operation rounds r, and sample size s. If Δε > ε_rem × threshold coefficient, the policy is immediately marked as infeasible and set to zero in subsequent scoring.

[0087] Furthermore, multi-objective scoring and objective strategy selection can include the following:

[0088] 1. Multi-objective scoring function

[0089] The state of a reinforcement learning agent (RL-Agent) includes a vector of computational resource consumption, a vector of budget occupancy, and historical sampling latency; the action is to select a candidate policy from the space; the reward function simultaneously minimizes resource cost and budget cost and maximizes task throughput.

[0090] 2. Scoring Process

[0091] The RL-Agent evaluates each candidate policy in the set and outputs a comprehensive score list S = {s_1, s_2, ..., s_n}. The policy mapping engine sorts the policies in descending order of s_i and sets the policy corresponding to s_max as the target privacy protection policy.

[0092] Furthermore, policy descriptor construction may include the following:

[0093] After locking onto the target policy, the central node generates a policy descriptor JSON fragment, whose fields include:

[0094] strategy_id: Unique identifier for the target strategy

[0095] proto_ptr: A pointer to protocol parameters (pointing to the differential privacy noise table or homomorphic encryption key length configuration).

[0096] key_index: The index number assigned by the key management service.

[0097] budget_tag: Budget deduction record identifier

[0098] op_seq_code: Operator sequence hash code

[0099] expire_ts: Strategy validity period timestamp

[0100] The descriptor, after being digested by SHA-256, is written to the scheduling cache along with the task scheduling plan for direct reference by the subsequent operator-level splitting and node scheduling modules.

[0101] Through the above implementation process, the platform can dynamically select the most suitable privacy protection strategy for joint computing tasks of power data while ensuring security and compliance, and achieve a multi-dimensional balance between resource utilization, privacy budget and computing performance.

[0102] In some embodiments, based on a policy descriptor, operator-level splitting and orchestration are performed on the privacy computing task to generate a task scheduling plan, including:

[0103] Read the operator sequence encoding, protocol parameter pointer and key index information in the policy descriptor, and construct a directed acyclic graph representing the data dependencies between operators based on the operator sequence encoding;

[0104] In a directed acyclic graph, a two-granularity segmentation is performed according to the protocol boundary and the data sensitivity level, merging atomic operators with the same privacy protection protocol and the same sensitivity level into execution fragments;

[0105] The distributed master-slave scheduling function of the operator scheduling module is invoked for each execution segment. Based on the resource quota information in the policy descriptor and the node capability label maintained by the central node, the execution segment is mapped to the target computing node and written into the node mapping table.

[0106] In the node mapping table, associate each execution segment with a corresponding key index or shared parameter identifier, and insert an intermediate state storage tag to indicate that the intermediate encryption result should be written to the encryption cache after the execution segment is completed.

[0107] The node mapping table, execution order queue, retry trigger conditions, and timeout thresholds are assembled into a task scheduling plan.

[0108] Specifically, the following uses the horizontal XGBoost joint modeling task as an example to illustrate the implementation process of "performing operator-level splitting and orchestration based on policy descriptors and generating task scheduling plans". The focus is on disclosing the methods of constructing directed acyclic graphs, dual-granularity segmentation, fragment mapping and scheduling plan encapsulation.

[0109] First, reading the policy descriptor and constructing the task directed acyclic graph can include the following:

[0110] After receiving the policy descriptor of the target privacy protection policy, the central node first parses the op_seq_code field and, in conjunction with the pre-set operator metadata table, recovers the complete operator sequence {O1, O2, ..., O...}. n The system then dynamically generates a directed acyclic graph (DAG_G(V,E)) in memory according to the data flow between operators, where V is the set of atomic operators and E is the data dependency edge. If the proto_ptr in the policy descriptor points to a hybrid protocol, a protocol flag is appended to the node attributes to facilitate subsequent segmentation.

[0111] Furthermore, dual-granularity segmentation can include the following:

[0112] 1. Protocol boundary segmentation

[0113] Traverse DAG_G and encounter adjacent operator pairs whose protocol tags have changed (O i O j At point E, a breakpoint is inserted to divide the area into different protocol blocks.

[0114] 2. Sensitivity level subdivision

[0115] Within the same protocol block, the vertex set is traversed again according to its sensitivity level label. If inconsistent sensitivity levels are found, further subdivision is performed. The final result is the execution fragment set {P1, P2, ..., P}. m This ensures that all atomic operators within each segment simultaneously satisfy the condition of "the same privacy protection protocol and the same sensitivity level".

[0116] Furthermore, performing fragment mapping and node capability matching can include the following:

[0117] 1. Resource quota reading

[0118] The central node reads the resource_quota field from the policy descriptor to obtain quota requirements such as the number of CPU cores, GPU computing power, and memory limit.

[0119] 2. Comparison of ability tags

[0120] For each execution segment Pk, filter a set of computing nodes Nk that meet the quota requirements and have a network latency lower than the threshold from the node registry. If the set is empty, trigger the degradation process and re-evaluate the next priority policy; if the set is non-empty, call the distributed master-slave scheduling function of the operator scheduling module to select the target node n* ∈ Nk according to the load balancing policy.

[0121] 3. Write to the node mapping table

[0122] Write <Pk, n*, key_index or share_id> to the node mapping table, and generate state_tag = "pending" for Pk. At the same time, append mid_store_flag = "true" under state_tag to indicate that the output needs to be written to the encrypted cache after the segment is completed.

[0123] Furthermore, the scheduling plan encapsulation may include the following:

[0124] The central node generates in sequence:

[0125] Execution order queue: Write P1 → P2 → … → P according to the DAG topological order m ;

[0126] Retry trigger conditions: Include the captured exception category, the number of consecutive failures, and the rollback depth;

[0127] Timeout threshold: Automatically estimate the execution duration according to the segment resource weight and multiply it by the coefficient k, and write it to the timeout field.

[0128] Merge the node mapping table, the execution order queue, the retry trigger conditions, and the timeout threshold into a task scheduling plan object, and add strategy_id and budget_tag to the head of the plan object for subsequent node verification of budget deduction and key index consistency.

[0129] Furthermore, the plan distribution may include the following:

[0130] The operator scheduling module sends the task scheduling plan to the target computing node through the control channel. After receiving the plan, the computing node creates an isolated running context according to the node mapping table and starts execution. If any segment execution fails and meets the retry conditions, it will automatically roll back to the intermediate encryption result of the nearest "completed" state segment and execute again; if the timeout threshold is exceeded, the node sends a timeout alert to the central node to trigger the dynamic policy adjustment process.

[0131] Through the above embodiments, those skilled in the art can combine power data scenarios to realize operator-level splitting, segmented mapping and scheduling plan generation based on policy descriptors, ensuring that the same privacy computing task is executed efficiently and rollbackably under mixed conditions of multiple protocols and multiple sensitivities.

[0132] In some embodiments, a sequence of privacy-preserving computation operators is executed on a computing node in a scheduled order, including:

[0133] After receiving the task scheduling plan, an isolated running context is created for each execution segment according to the node mapping table, and key materials and protocol plugins corresponding to the key index or shared parameter identifier are loaded.

[0134] The execution sequence queue is used to retrieve the segments to be executed in turn. In the isolated execution context, the atomic operators within the segments of the hardware trusted execution environment are called to perform encryption / decryption or security operations on the input data according to the corresponding privacy protection protocol.

[0135] At the end of the segment execution, the generated intermediate encryption result is written to the encryption cache, and the segment completion status and replay verification digest are recorded at the storage location indicated by the intermediate state storage marker.

[0136] The execution status of the segment and the resource usage count are periodically reported to the central node. When the retry trigger condition or timeout threshold is detected, the segment is automatically rolled back to the intermediate state of the most recent successful record and the current segment is re-executed.

[0137] After all segments of the privacy computation operator sequence have been executed, the final encrypted result and complete resource usage count are encapsulated according to the task scheduling plan and returned to the central node.

[0138] Specifically, the following embodiment takes computing node n1 deployed in the Hohhot data domain of Inner Mongolia as an example to illustrate the whole process of "executing the privacy computing operator sequence in the scheduling order on the computing node", highlighting key technical details such as isolated running context creation, trusted execution environment invocation, intermediate state persistence and rollback control.

[0139] First, the creation of the isolated runtime context and key loading can include the following:

[0140] After receiving the task scheduling plan from the central node, compute node n1 first parses the node mapping table and creates independent running contexts Ctx1, Ctx3, and Ctx4 for the execution fragments P1, P3, and P4 mapped to n1, respectively. During the initialization of each context, it retrieves the 128-bit session key matching the key_index field or the secret sharing fragment matching the share_id from the local key management module. Then, it dynamically loads the differential privacy noise generator or homomorphic encryption library according to the protocol plugin version number pointed to by proto_ptr, ensuring that the running environment is consistent with the policy descriptor.

[0141] Furthermore, operator execution within a trusted execution environment can include the following:

[0142] The compute node binds Ctx1 to a Hardware Trusted Execution Environment (TEE) instance and runs in SGX enclave mode. At startup, the TEE verifies the module signature and locks memory pages. The scheduler retrieves the first atomic operator O1 (ciphertext gradient addition) of segment P1 from the execution order queue, feeds the input ciphertext gradient block into the TEE, and performs element-wise addition on the ciphertext vector using a homomorphic addition operator. Immediately after completing the computation, the TEE returns the ciphertext result and calls the anti-side-channel padding function to erase register remnants.

[0143] Furthermore, writing intermediate encryption results to status flags may include the following:

[0144] After all atomic operators within fragment P1 have been executed sequentially, Ctx1 writes the ciphertext result to the node's local high-performance encrypted cache, CipherCache, with the cache entry key being task_id + fragment ID hash. Subsequently, the fragment completion status "completed" and a replay verification digest are written to the storage location pointed to by the intermediate state storage marker. The digest is generated by SHA-256 calculation of the ciphertext result and the fragment signature, for future rollback or cross-node state verification.

[0145] Furthermore, status and resource reporting and automatic rollback can include the following:

[0146] Every 3 seconds, the node monitoring daemon summarizes the CPU utilization, memory usage, and I / O wait times of Ctx1, Ctx3, and Ctx4, packages them into a resource usage count, and reports it to the central node along with the fragment execution status via an encrypted heartbeat channel. If the central node returns a "P3 retry" instruction or the node detects locally that the P3 execution time exceeds the timeout threshold, the scheduler pauses Ctx3, finds the most recent intermediate state entry marked "completed," reloads the encrypted data corresponding to that entry from CipherCache into the TEE input buffer, resets the rollback count, and re-executes the unfinished atomic operators in P3 in the original order.

[0147] Furthermore, encapsulating the final result and sending it back can include the following:

[0148] When the execution sequence queue is empty and all fragments in the node mapping table are in the "completed" state, the node calls the ciphertext encapsulation interface of the protocol plugin in Ctx4 to encapsulate the final model parameter ciphertext along with the budget deduction pipeline identifier into a result package ResultPkg. The result includes the task ID, node ID, ciphertext length, cumulative resource usage count, and verification digest. The node sends the ResultPkg back through the uplink data channel pre-configured by the central node, thus ending the privacy computation operator sequence execution flow of computation node n1.

[0149] In some embodiments, if a resource threshold or budget threshold is detected to be triggered, the step of retrieving the set of candidate privacy protection policies to generate a task scheduling plan is re-executed based on resource usage data and usage metering data to adjust the target privacy protection policy, including:

[0150] At the central node, resource usage data is compared with a preset multi-dimensional resource threshold vector, and usage measurement data is compared with a remaining privacy budget threshold vector. If any threshold is triggered, an fitness factor is generated.

[0151] Taking the fitness factor, the current policy descriptor, and the original set of candidate privacy protection policies as input, the incremental candidate policy selection algorithm is executed, and the adjusted set of candidate privacy protection policies is output.

[0152] The computational resource consumption parameters and privacy budget occupancy parameters are re-evaluated based on the adjusted set of candidate privacy protection strategies, and a new target privacy protection strategy is determined according to the predetermined scoring rules, generating an incremental strategy descriptor corresponding to the new target privacy protection strategy.

[0153] Based on the incremental strategy descriptor, the execution segments that have not yet started execution or are in a rollback state are split and rearranged at the differential operator level to obtain the incremental task scheduling plan, which is then distributed to the affected computing nodes through the central node.

[0154] After receiving the incremental task scheduling plan, the computing node only pauses the affected execution segments, loads the protocol plugin and key materials corresponding to the incremental policy descriptor, continues to execute the adjusted privacy computing operator sequence, and synchronizes the incremental resource usage count and budget deduction status to the central node.

[0155] Specifically, the following example illustrates the dynamic policy adjustment process triggered by resource and budget thresholds, using the operation of a computing cluster in a monitoring area of ​​a central node in a certain location during a horizontal neural network training task. After the task begins, the central node parses the resource usage data packets returned from the computing nodes every 5 seconds. These packets include CPU core usage (0.77%), GPU memory usage (0.86%), network bandwidth usage (0.48%), and cumulative power consumption. Simultaneously, it calls the usage metering mechanism to read the remaining privacy budget ε_rem, with an initial value of 1.2. The platform's preset multi-dimensional resource threshold vector is [0.8, 0.85, 0.6], and the budget threshold vector is 0.25 × ε_init. When monitoring period t6 arrives, the GPU memory usage (0.87%) exceeds the threshold of 0.85, and the cumulative budget consumption Δε reaches 1.0. The central node immediately generates fitness factors λ_res = 1.04 and λ_budget = 0.92, and enters the incremental reassessment process.

[0156] Furthermore, the central node first feeds λ_res, λ_budget, the current policy descriptor S_cur, and the original candidate policy set {HE-full, SS+DP, HE+DP-mix} into the incremental candidate policy selection algorithm. The algorithm employs a soft elimination mechanism with a temperature coefficient τ: for each candidate policy, calculate Π = λ_res × R_norm + λ_budget × B_norm; if Π > τ, retain it; otherwise, eliminate it. The evaluation results of this round eliminate the HE-full scheme, retaining the SS+DP and HE+DP-mix schemes, and adding resource compensation weights to them.

[0157] Subsequently, the central node re-invokes the graph convolutional resource prediction model and budget occupancy model, outputting new resource consumption and budget occupancy vectors for the retention policy. The GPU prediction ratio for the SS+DP scheme drops to 0.63, and the budget occupancy Δε prediction is 0.12; the GPU prediction ratio for the HE+DP-mix scheme is 0.79, and the budget occupancy Δε prediction is 0.16. The reinforcement learning scoring function outputs scores S_SS = 0.91 and S_mix = 0.85. The system selects the policy corresponding to S_SS as the new target privacy protection policy and generates an incremental policy descriptor S_inc, updating proto_ptr to point to the secret sharing library v3.2 and the Laplacian noise generator v1.5.

[0158] Furthermore, the operator scheduling module reads S_inc and initiates differential splitting for the unexecuted execution segments P5 to P8: the gradient merging operator, which originally used a homomorphic encryption protocol, is split into a "shared fragmentation-local aggregation" biatomic operator, and the dependency subgraph is reconstructed. Simultaneously, the node mapping table is updated to migrate GPU-intensive operators to the Hulunbuir node n5, which has a higher GPU idle rate. The generated incremental task scheduling plan only includes the affected segments, the updated node mapping, and the new timeout threshold, and is then distributed to n3 and n5 through the central node's secure channel.

[0159] Furthermore, upon receiving the incremental scheduling plan, compute node n3 suspends the queued P6, loads the secret shared library v3.2 and key fragment k3, and maintains the encrypted cache of completed fragments unchanged. Node n5 creates a new runtime context Ctx_new, loads the Laplace noise generator v1.5, and anonymizes the migrated local aggregation operators. After both nodes complete the fragment adjustment, they continue running according to the new execution order, carrying incremental resource occupancy counts and budget deduction status in their heartbeat packets for real-time correction by the central node.

[0160] The final neural network training was completed under the new strategy combination, with the peak GPU memory usage compressed to 0.74, budget consumption Δε maintained within 0.18, and overall task latency increasing by no more than 6%. The central node archived the resource curves and budget curves before and after the adjustment to the monitoring report, marking the completion of this dynamic adjustment process.

[0161] This embodiment demonstrates that when resource or budget pressures are triggered, the platform can quickly identify abnormal indicators, filter new candidate strategies, generate incremental strategy descriptors, and differentially distribute scheduling plans. This allows unfinished segments to switch to a privacy-protected protocol with lower resource utilization and more controllable budget consumption without interrupting the overall task, significantly improving the resilience and economy of task execution.

[0162] The following are embodiments of the apparatus described in this application, which can be used to execute the embodiments of the method described in this application. For details not disclosed in the apparatus embodiments of this application, please refer to the embodiments of the method described in this application.

[0163] Figure 2 This is a schematic diagram of the structure of the privacy computing dynamic strategy selection device based on data sensitivity identification provided in an embodiment of this application. Figure 2 As shown, the privacy computing dynamic strategy selection device based on data sensitivity identification includes:

[0164] The parsing module 201 is used to obtain the privacy computing task request to be executed and parse it to obtain the target data set and the corresponding operation type;

[0165] The identification module 202 is used to perform sensitivity identification on each field in the target dataset and obtain the sensitivity level label corresponding to each field.

[0166] The retrieval module 203 is used to retrieve a set of candidate privacy protection strategies from a preset strategy mapping relationship based on the operation type and sensitivity level label.

[0167] Evaluation module 204 is used to evaluate the computational resource consumption parameters and privacy budget usage parameters of each candidate privacy protection strategy set, determine the target privacy protection strategy according to the predetermined scoring rules, and generate a strategy descriptor corresponding to the target privacy protection strategy.

[0168] The generation module 205 is used to perform operator-level splitting and orchestration of privacy computing tasks according to the policy descriptor and generate a task scheduling plan, wherein the task scheduling plan indicates the sequence of privacy computing operators and the scheduling order.

[0169] The distribution module 206 is used to distribute the task scheduling plan and the key or shared parameters matching the target privacy protection strategy to the computing nodes through the central node, and execute the privacy computing operator sequence in the scheduling order on the computing nodes.

[0170] The adjustment module 207 is used to collect resource usage data and usage measurement data reported by computing nodes. If the resource threshold or budget threshold is detected to be triggered, the step of retrieving the set of candidate privacy protection policies to generate a task scheduling plan is re-executed based on the resource usage data and usage measurement data in order to adjust the target privacy protection policy.

[0171] Return module 208 is used to return the privacy computation result to the caller after the privacy computation operator sequence has been executed, thus completing the privacy computation task.

[0172] In some embodiments, Figure 2 The identification module 202 acquires the metadata associated with the field, and performs semantic parsing, statistical distribution analysis, and cross-domain access trajectory hash encoding sequentially based on the metadata to generate a field feature vector that integrates semantic features, statistical features, and temporal features. The field feature vector is input into a multi-task sensitivity classification model that is deployed locally on each computing node and jointly trained by the central node using a secret sharing protocol. The multi-task sensitivity classification model uses a lightweight multi-layer self-attention encoder and shares a set of interpretable attention weights. The sensitivity level label corresponding to the field is inferred locally on each computing node, and the sensitivity level label is written into the metadata repository for retrieval and calling by the policy mapping relationship.

[0173] In some embodiments, Figure 2The retrieval module 203 constructs a multi-dimensional composite key containing operation type identifier, sensitivity level label, administrative domain identifier of the data, and real-time resource load threshold; it uses the multi-dimensional composite key to perform parallel retrieval in a two-layer mapping structure maintained by the policy mapping engine. The two-layer mapping structure consists of a high-dimensional index table based on hash prefix compression and a directed acyclic policy graph divided according to policy priority; it traverses along the in-degree edges matching the operation type identifier and sensitivity level label to the leaf nodes in the directed acyclic policy graph, and collects the privacy protection policy set identified by the reached leaf nodes as a candidate privacy protection policy set.

[0174] In some embodiments, Figure 2 The evaluation module 204 calls real-time node resource telemetry data, combines it with the operator execution configuration of candidate privacy protection strategies, and uses an adaptive resource prediction model built based on graph convolutional networks to output the computational resource consumption vector corresponding to each candidate privacy protection strategy; it calls the current remaining privacy budget value and calculates the budget occupancy vector corresponding to each candidate privacy protection strategy based on a preset privacy budget occupancy model; based on the computational resource consumption vector and the budget occupancy vector, it calls a reinforcement learning-driven multi-objective scoring function to generate a comprehensive score list, and selects the strategy with the highest score as the target privacy protection strategy according to the comprehensive score list; after selecting the target privacy protection strategy, it constructs a strategy descriptor containing a strategy identifier, protocol parameter pointer, key index, budget deduction identifier, and operator sequence encoding.

[0175] In some embodiments, Figure 2 The generation module 205 reads the operator sequence encoding, protocol parameter pointer, and key index information from the policy descriptor, and constructs a directed acyclic graph (DAG) representing the data dependencies between operators based on the operator sequence encoding. In the DAG, it performs dual-granularity segmentation according to protocol boundaries and data sensitivity levels, merging atomic operators with the same privacy protection protocol and the same sensitivity level into execution fragments. For each execution fragment, it calls the distributed master-slave scheduling function of the operator scheduling module, mapping the execution fragments to target computing nodes based on the resource quota information in the policy descriptor and the node capability tags maintained by the central node, and writing this information into the node mapping table. In the node mapping table, it associates each execution fragment with a corresponding key index or shared parameter identifier and inserts an intermediate state storage marker to indicate that the intermediate encryption result should be written to the encryption cache after the execution fragment is completed. Finally, it assembles the node mapping table, execution order queue, retry trigger conditions, and timeout threshold into a task scheduling plan.

[0176] In some embodiments, Figure 2After receiving the task scheduling plan, the distribution module 206 creates an isolated running context for each execution segment according to the node mapping table, and loads the key materials and protocol plugins corresponding to the key index or shared parameter identifier. It sequentially retrieves the segments to be executed from the execution order queue, calls the atomic operators within the hardware trusted execution environment in the isolated running context, and performs encryption / decryption or security operations on the input data according to the corresponding privacy protection protocol. When the segment execution ends, it writes the generated intermediate encryption result to the encryption cache, and records the segment completion status and replay verification digest at the storage location indicated by the intermediate state storage marker. It periodically reports the segment execution status and resource usage count to the central node. When the retry trigger condition or timeout threshold is detected, it automatically rolls back to the most recently successfully recorded intermediate state and re-executes the current segment. After all segments of the privacy computation operator sequence have been executed, it encapsulates the final encryption result and complete resource usage count according to the task scheduling plan and returns it to the central node.

[0177] In some embodiments, Figure 2 The adjustment module 207 compares resource consumption data with a preset multi-dimensional resource threshold vector and usage measurement data with a remaining privacy budget threshold vector at the central node. If any threshold is triggered, a fitness factor is generated. Using the fitness factor, the current policy descriptor, and the original set of candidate privacy protection policies as input, an incremental candidate policy screening algorithm is executed, and an adjusted set of candidate privacy protection policies is output. Based on the adjusted set of candidate privacy protection policies, the computational resource consumption parameters and privacy budget consumption parameters are re-evaluated, and a new target privacy protection policy is determined according to a predetermined scoring rule, generating an incremental policy descriptor corresponding to the new target privacy protection policy. According to the incremental policy descriptor, the execution segments that have not yet started execution or are in a rollback state are split and rearranged at the differential operator level to obtain an incremental task scheduling plan, which is then distributed to the affected computing nodes through the central node. After receiving the incremental task scheduling plan, the computing nodes only pause the affected execution segments, load the protocol plugin and key materials corresponding to the incremental policy descriptor, continue to execute the adjusted privacy computation operator sequence, and simultaneously synchronize the incremental resource consumption count and budget deduction status to the central node.

[0178] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0179] Figure 3 This is a schematic diagram of the structure of the electronic device 3 provided in an embodiment of this application. Figure 3As shown, the electronic device 3 of this embodiment includes a processor 301, a memory 302, and a computer program 303 stored in the memory 302 and executable on the processor 301. When the processor 301 executes the computer program 303, it implements the steps in the various method embodiments described above. Alternatively, when the processor 301 executes the computer program 303, it implements the functions of each module / unit in the various device embodiments described above.

[0180] For example, computer program 303 may be divided into one or more modules / units, which are stored in memory 302 and executed by processor 301 to complete this application. The one or more modules / units may be a series of computer program instruction segments capable of performing a specific function, which describe the execution process of computer program 303 in electronic device 3.

[0181] Electronic device 3 can be a desktop computer, laptop, handheld computer, cloud server, or other electronic device. Electronic device 3 may include, but is not limited to, processor 301 and memory 302. Those skilled in the art will understand that... Figure 3 This is merely an example of electronic device 3 and does not constitute a limitation on electronic device 3. It may include more or fewer components than shown, or combine certain components, or different components. For example, electronic device may also include input / output devices, network access devices, buses, etc.

[0182] Processor 301 can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor can be a microprocessor or any conventional processor.

[0183] The memory 302 can be an internal storage unit of the electronic device 3, such as a hard disk or RAM. The memory 302 can also be an external storage device of the electronic device 3, such as a plug-in hard disk, Smart Media Card (SMC), Secure Digital (SD) card, or Flash Card. Furthermore, the memory 302 can include both internal and external storage units of the electronic device 3. The memory 302 is used to store computer programs and other programs and data required by the electronic device. The memory 302 can also be used to temporarily store data that has been output or will be output.

[0184] 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 merely 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. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above system can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0185] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0186] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0187] In the embodiments provided in this application, it should be understood that the disclosed apparatus / computer devices and methods can be implemented in other ways. For example, the apparatus / computer device embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. Multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection of apparatus or units may be electrical, mechanical, or other forms.

[0188] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0189] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0190] If integrated modules / units are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program may include computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. Computer-readable media may include: any entity or device capable of carrying computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc.

[0191] The above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although the technical solutions of this application are 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 spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.

Claims

1. A privacy computing dynamic strategy selection method based on data sensitivity recognition, characterized in that, The method comprises the following steps: obtaining a privacy computing task request to be executed, and parsing to obtain a target data set and a corresponding operation type; performing sensitivity identification on each field in the target data set to obtain a sensitivity level label corresponding to each field; according to the operation type and the sensitivity level label, retrieving a candidate privacy protection strategy set from a preset strategy mapping relationship; for the candidate privacy protection strategy set, evaluating the calculation resource consumption parameter and the privacy budget occupation parameter of each strategy, and determining a target privacy protection strategy according to a predetermined scoring rule, and generating a strategy descriptor corresponding to the target privacy protection strategy; according to the strategy descriptor, performing operator-level splitting and arrangement on the privacy computing task to generate a task scheduling plan, wherein the task scheduling plan indicates a privacy computing operator sequence and a scheduling order; through a center node, issuing the task scheduling plan and a key or a shared parameter matched with the target privacy protection strategy to a computing node, and executing the privacy computing operator sequence in the computing node according to the scheduling order; collecting resource occupation data and usage metering data reported by the computing node, and if it is detected that a resource threshold or a budget threshold is triggered, re-executing the steps of retrieving a candidate privacy protection strategy set to generating a task scheduling plan based on the resource occupation data and the usage metering data to adjust the target privacy protection strategy; after the execution of the privacy computing operator sequence is completed, returning a privacy computing result to a calling party to complete the privacy computing task.

2. The method of claim 1, wherein, The method comprises the following steps: obtaining metadata associated with the field, and generating a field feature vector fused with semantic features, statistical features and time sequence features by sequentially performing semantic analysis, statistical distribution analysis and cross-domain access trajectory hash coding based on the metadata; inputting the field feature vector into a multi-task sensitivity classification model locally deployed on each computing node and jointly trained by the center node using a secret sharing protocol, wherein the multi-task sensitivity classification model uses a lightweight multi-layer self-attention encoder and shares a set of explainable attention weights; locally inferring the sensitivity level label corresponding to the field on each computing node, and writing the sensitivity level label into a metadata warehouse for strategy mapping relationship retrieval.

3. The method of claim 1, wherein, The method comprises the following steps: constructing a multi-dimensional combination key containing an operation type identifier, a sensitivity level label, a data administrative domain identifier and a real-time resource load threshold; performing parallel retrieval in a double-layer mapping structure maintained by a strategy mapping engine using the multi-dimensional combination key, wherein the double-layer mapping structure is composed of a high-dimensional index table based on hash prefix compression and a directed acyclic strategy graph divided according to strategy priority; in the directed acyclic strategy graph, traverse to a leaf node along an in-degree edge matched with the operation type identifier and the sensitivity level label, and collect the privacy protection strategy set identified by the reached leaf node as the candidate privacy protection strategy set.

4. The method of claim 1, wherein, The evaluation of each strategy includes a calculation resource consumption parameter and a privacy budget occupation parameter, and a target privacy protection strategy is determined according to a predetermined scoring rule, and a strategy descriptor corresponding to the target privacy protection strategy is generated, including: The real-time node resource telemetry data is called, combined with the operator execution configuration of the candidate privacy protection strategy, and an adaptive resource prediction model based on a graph convolution network is used to output a calculation resource consumption vector corresponding to each candidate privacy protection strategy; The current remaining privacy budget value is called, and a budget occupation vector corresponding to each candidate privacy protection strategy is calculated based on a preset privacy budget occupation model; According to the calculation resource consumption vector and the budget occupation vector, a comprehensive score list is generated by calling a multi-objective scoring function driven by reinforcement learning, and the highest score strategy is selected as the target privacy protection strategy according to the comprehensive score list; After the target privacy protection strategy is selected, a strategy descriptor containing a strategy identifier, a protocol parameter pointer, a key index, a budget deduction identifier, and an operator sequence code is constructed.

5. The method of claim 1, wherein, According to the strategy descriptor, operator-level splitting and arrangement are performed on the privacy computing task to generate a task scheduling plan, including: Read the operator sequence code, protocol parameter pointer, and key index information in the strategy descriptor, and build a directed acyclic graph representing the data dependency relationship between operators based on the operator sequence code; In the directed acyclic graph, perform double-granularity segmentation according to protocol boundaries and data sensitivity levels, and merge atomic operators of the same privacy protection protocol and the same sensitivity level into execution fragments; For each execution fragment, call the distributed master-slave scheduling function of the operator scheduling module, and according to the resource quota information in the strategy descriptor and the node capability label maintained by the center node, map the execution fragment to the target computing node and write it into the node mapping table; In the node mapping table, associate the corresponding key index or shared parameter identifier for each execution fragment, and insert an intermediate state storage marker to indicate that the intermediate encrypted result will be written to the encrypted cache after the execution fragment is completed; Assemble the node mapping table, execution order queue, retry trigger condition, and timeout threshold into the task scheduling plan.

6. The method of claim 1, wherein, The execution of the privacy computing operator sequence on the computing node according to the scheduling order includes: After receiving the task scheduling plan, create an isolated running context for each execution fragment according to the node mapping table, load the key material and protocol plug-in corresponding to the key index or shared parameter identifier; Take out the execution fragment to be executed from the execution order queue one by one, and call the hardware trusted execution environment in the isolated running context to execute the atomic operators in the execution fragment, and perform encryption and decryption or security operations of the corresponding privacy protection protocol on the input data; When the execution of the fragment is completed, write the generated intermediate encrypted result to the encrypted cache, and record the fragment completion state and replay verification digest at the storage site indicated by the intermediate state storage marker; Periodically report the fragment execution state and resource occupation count to the center node, and when the retry trigger condition or the timeout threshold is met, automatically roll back to the last successfully recorded intermediate state and re-execute the current fragment; After all fragments of the sequence of privacy computation operators are executed, the final encrypted result and complete resource occupation count are encapsulated according to the task scheduling plan, and returned to the center node.

7. The method of claim 1, wherein, If the resource threshold or the budget threshold is triggered, the steps of searching for the candidate privacy protection strategy set to generating the task scheduling plan are re-executed based on the resource occupation data and the usage measurement data, so as to adjust the target privacy protection strategy, including: The center node compares the resource occupation data with a preset multi-dimensional resource threshold vector, and compares the usage measurement data with a residual privacy budget threshold vector. If any threshold is triggered, an adaptability factor is generated; The adaptability factor, the current strategy descriptor and the original candidate privacy protection strategy set are taken as inputs to execute an incremental candidate strategy screening algorithm, and an adjusted candidate privacy protection strategy set is output; Based on the adjusted candidate privacy protection strategy set, the calculation resource consumption parameter and the privacy budget occupation parameter are re-evaluated, and a new target privacy protection strategy is determined according to a predetermined scoring rule, and an incremental strategy descriptor corresponding to the new target privacy protection strategy is generated; According to the incremental strategy descriptor, the execution fragments that have not started execution or are in a rollbackable state are differentially split and rearranged at the operator level to obtain an incremental task scheduling plan, and the center node is used to issue the incremental task scheduling plan to the affected computing nodes; After the computing nodes receive the incremental task scheduling plan, only the affected execution fragments are suspended, the protocol plug-in and the key material corresponding to the incremental strategy descriptor are loaded, the adjusted privacy computation operator sequence is continued to be executed, and the incremental resource occupation count and the budget deduction state are synchronized to the center node.

8. An apparatus for dynamic strategy selection of privacy computation based on data sensitivity identification, characterized in that, Comprising: The parsing module is used to obtain a privacy computation task request to be executed, and to parse a target data set and a corresponding operation type; The identification module is used to perform sensitivity identification on each field in the target data set to obtain a sensitivity level label corresponding to each field; The search module is used to search for a candidate privacy protection strategy set from a preset strategy mapping relationship according to the operation type and the sensitivity level label; The evaluation module is used to evaluate the calculation resource consumption parameter and the privacy budget occupation parameter of each strategy for the candidate privacy protection strategy set, and to determine a target privacy protection strategy according to a predetermined scoring rule, and to generate a strategy descriptor corresponding to the target privacy protection strategy; The generation module is used to perform operator-level splitting and arrangement on the privacy computation task according to the strategy descriptor to generate a task scheduling plan, wherein the task scheduling plan indicates a sequence of privacy computation operators and a scheduling order; The delivery module is used to deliver the task scheduling plan and the key or shared parameter matched with the target privacy protection strategy to the computing nodes through the center node, and to execute the sequence of privacy computation operators in the computing nodes according to the scheduling order. An adjusting module is configured to collect resource occupation data and usage metering data reported by the computing node, and if it is detected that a resource threshold or a budget threshold is triggered, then the steps of searching for a candidate privacy protection strategy set and generating a task scheduling plan are re-executed based on the resource occupation data and usage metering data, so as to adjust the target privacy protection strategy. A returning module is configured to return a privacy computation result to a calling party after the sequence of privacy computation operators is executed, so as to complete the privacy computation task.

9. An electronic device comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, characterized in that, The processor executes the computer program to implement the steps of the method according to any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, the computer-readable storage medium comprising: The computer program is executed by the processor to implement the steps of the method according to any one of claims 1 to 7.

Images