Intelligent management method and system for medical data security sharing and privacy calculation based on game theory

Abstract

The application discloses a kind of medical data security sharing and privacy computing intelligent management method and system fusing game theory, comprising: obtaining medical institution basic configuration and historical behavior data, constructs privacy mechanism capability directory and calculates initial trust state vector;Receive privacy computing task, parse and generate multi-channel privacy path candidate set;Based on the trust vector as a constraint, construct and solve heterogeneous privacy path selection game, derive task privacy execution path plan;Scheduling agency executes calculation and collects actual execution behavior index;According to actual behavior, update trust state vector, and generate privacy mode upgrade strategy.The application solves the problem that static strategy cannot adapt to the heterogeneity and dynamics of institutions through dynamic closed loop of trust-strategy-behavior, balances the global utility of alliance and local interests of institutions using game theory, and realizes adaptive optimization of safety and efficiency.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of medical data security sharing and privacy computing, in particular to a medical data security sharing and privacy computing intelligent management method and system fusing game theory. BACKGROUND

[0002] Medical data, as a key production factor, contains great scientific research and clinical value, especially in the field of artificial intelligence assisted diagnosis and public health research. However, due to the involvement of highly sensitive personal privacy and the dispersion of data in different institutions, the phenomenon of data island has formed. Therefore, how to realize the security sharing and collaborative computing of cross-institutional medical data under the premise of guaranteeing data security and privacy compliance has become an important issue to be solved in the field of smart medical care.

[0003] At present, in order to solve the privacy problem in data collaborative computing, researchers have proposed various technical paths. As a mainstream framework, federated learning allows parties to jointly train models without exchanging raw data. Under this framework, cryptographic and privacy protection technologies such as homomorphic encryption HE, secure multi-party computation MPC and differential privacy DP are widely used. For example, some schemes use homomorphic encryption to aggregate intermediate data (such as gradients), or use secure multi-party computation to realize specific statistical analysis, and other schemes add noise to the output results through local differential privacy to protect data.

[0004] The existing technical solutions have obvious deficiencies in dealing with the heterogeneity and dynamics of multi-institutional collaboration. These solutions often use static privacy configurations and lack dynamic consideration of participant behavior, and it is also difficult to achieve the optimal combination of heterogeneous privacy technologies in complex tasks. First, existing management strategies are usually one-size-fits-all, applying the same static privacy and security strategy to all participating institutions regardless of their historical performance. This approach cannot motivate efficient participation by trusted institutions, such as forcing high-reputation institutions to use high-overhead channels, and cannot dynamically punish or restrict institutions that behave unacceptably, such as allowing low-reputation institutions to access high-risk low-overhead channels, resulting in a difficult balance between the overall efficiency and security level of the alliance. Second, when faced with complex analysis composed of multiple sub-tasks, existing solutions lack a refined privacy path selection mechanism. They tend to preset a homogeneous privacy technology for the entire task, such as using secure multi-party computation throughout, ignoring the huge differences in privacy risk and computing overhead between different sub-tasks such as local computation and cross-institution aggregation, as well as the heterogeneity of institutions in privacy capabilities (such as homomorphic encryption, trusted environment, etc.), ultimately leading to low computing efficiency or excessive / inadequate privacy protection. SUMMARY

[0005] The application aims to provide a medical data security sharing and privacy computing intelligent management method and system combined with game theory, so as to solve one of the problems existing in the prior art.

[0006] The technical scheme is a medical data security sharing and privacy computing intelligent management method combined with game theory, comprising the following steps:

[0007] Obtaining alliance organization basic configuration data and historical behavior audit data of a medical institution, and constructing a privacy mechanism capability directory and an initial trust state vector based on the data;

[0008] Receiving privacy computing task request data, combining the privacy mechanism capability directory, analyzing the task to generate a multi-channel privacy path candidate set;

[0009] Based on the multi-channel privacy path candidate set and the initial trust state vector, constructing and solving a heterogeneous privacy path selection game, and deriving a task privacy execution path plan;

[0010] According to the task privacy execution path plan, scheduling the medical institution to perform joint privacy computing, and collecting actual execution behavior index data;

[0011] According to the actual execution behavior index data, updating the trust state to obtain an alliance trust state vector, and generating privacy mode upgrade strategy data based on the alliance trust state vector.

[0012] The application solves the problem that a static strategy cannot adapt to the heterogeneity and dynamics of an organization through a dynamic closed loop of trust-strategy-behavior, balances the global utility of an alliance and the local interests of an organization by using game theory, and realizes adaptive optimization of safety and efficiency. BRIEF DESCRIPTION OF DRAWINGS

[0013] Figure 1 The figure is a whole flowchart of the application.

[0014] Figure 2 The figure is a flowchart of the application for deriving a task privacy execution path plan.

[0015] Figure 3 The figure is a flowchart of the application for converting to generate organization trust constraint parameter data.

[0016] Figure 4 The figure is a flowchart of the application for constructing path selection game modeling data. DETAILED DESCRIPTION

[0017] Embodiment 1: describes the complete process of the medical data security sharing and privacy computing intelligent management method combined with game theory, and the system architecture for realizing the method.

[0018] Step 101, obtain the alliance organization basic configuration data and historical behavior audit data of the medical institutions, and construct a privacy mechanism capability directory and calculate an initial trust state vector based on the data. In other words, construct a privacy mechanism capability directory based on the alliance organization basic configuration data, and calculate an initial trust state vector based on the historical behavior audit data.

[0019] In this embodiment, the processor of the system first reads two types of basic data from the memory. The first type is the alliance organization basic configuration data. This data is structured electronic data, such as stored in a data table or a JSON document, which objectively records the privacy computing capabilities and resource status of each medical institution member in the alliance.

[0020] Specifically, the data structure can include: organization identification, whether to support homomorphic encryption (HE) capability, whether to support secure multi-party computation (MPC) capability, whether to support trusted execution environment (TEE) capability, available network bandwidth (e.g. 1000 Mbps), and calculation cost coefficient (e.g. 0.8), etc. These data reflect the objective physical and logical resources of each institution. The second type is the historical behavior audit data. This data is a log-type data structure that objectively records the historical performance of each institution in past tasks, such as containing task identification, organization identification, task submission status (e.g. on time or overtime), compliance review results, such as compliance or violation, and audit quality score (e.g. 0.9), etc.

[0021] On this basis, the processor constructs a privacy mechanism capability directory based on the alliance organization basic configuration data. This directory is an index or mapping table generated by the processor and stored in the memory or database, which is used to explicitly indicate which institutions support each privacy technology, such as homomorphic encryption, secure multi-party computation, and their corresponding performance indicators in the alliance. At the same time, the processor calculates the initial trust state vector of each institution according to the historical behavior audit data. The vector adopts a data structure, such as an array, whose components correspond to the initial trust scores of each institution. This calculation process is objective, such as based on historical on-time completion rate and compliance violation rate, etc. to obtain a weighted result, aiming to provide an initial trust baseline based on historical performance for subsequent game decision-making.

[0022] Step 102, receive privacy computing task request data, combine the privacy mechanism capability directory, and parse the task to generate a multi-channel privacy path candidate set.

[0023] In this embodiment, one communication interface of the system receives a privacy computation task request data from an upper layer application, such as a task request data from a medical research platform, which is a structured electronic data package with a specific format (e.g. XML or JSON) containing specific requirements of this computation task, such as target analysis type, such as federated logistic regression or population characteristic statistics, task time urgency parameter, expected result precision requirement and target patient set screening condition, etc.

[0024] After the processor of the system receives the request data, it first parses it. The parsing process includes: according to the target analysis type, decomposing the complex computation task into a series of interdependent sub-computation steps, and constructing a task function dependency graph. The graph is a directed acyclic graph DAG data structure stored in memory, whose nodes represent each sub-task, and the directed edges represent the data flow and execution dependency relationship between sub-tasks. Then, the processor traverses each sub-task node in the graph and queries the privacy mechanism capability directory generated in step 101 to find all feasible privacy channel solutions that can execute the sub-task. Here, the privacy channel refers to a specific, game-selectable execution instance (such as a secure multi-party computation channel executed by institutions A and B), which is distinguished from the abstract capability of privacy mechanism.

[0025] The processor combines these feasible channel solutions to form a multi-channel privacy path candidate set. Each element in the set represents a complete execution path from the beginning to the end of the task, which is composed of a series of specific privacy channels selected for each sub-task. Importantly, when generating this set, the processor estimates the total cost of each candidate path, such as based on the computation and communication resource consumption of each channel, and the total privacy risk, such as based on the privacy leakage model estimation of each channel.

[0026] Step 103, based on the multi-channel privacy path candidate set and the initial trust state vector, construct and solve the heterogeneous privacy path selection game, derive the task privacy execution path plan.

[0027] In this embodiment, the game solving module of the system (executed by the processor) is responsible for this step. This step models the privacy computation path selection problem as a multi-participant game process. Specifically, the processor takes the multi-channel privacy path candidate set generated in step 102 as the strategy space of the game, i.e. the set of actions that each party can take, and takes the initial trust state vector calculated in step 101 as the constraint condition of the game. For example, institutions with low trust scores will have their strategy options in high-risk privacy channels (such as low intensity differential privacy) limited or penalized.

[0028] The processor then constructs and solves a heterogeneous privacy path selection game, aiming to find one or a set of equilibrium solutions that optimize the overall utility of the alliance (e.g., balancing computational efficiency, cost, and privacy risks) while also considering the local interests of each participating organization (e.g., minimizing their own costs). The game solution is derived as a task privacy execution path plan. This plan is a specific and unique set of execution instructions that clearly specifies which privacy channel scheme each subtask node should adopt and which organizations will be responsible for its execution. This plan will serve as the direct basis for the next step of physical execution.

[0029] Step 104: Based on the task privacy execution path plan, schedule medical institutions to perform joint privacy computation and collect actual execution behavior indicator data.

[0030] This is the physical execution and monitoring phase of the invention. The system's execution acquisition module (executed by the processor) sends specific control commands and scheduling signals to the computing nodes of each medical institution in the consortium, based on the task privacy execution path plan derived in step 103. Upon receiving the commands, the computing devices of each medical institution process local data and perform joint privacy computation according to the privacy channel scheme specified in the plan, such as performing local data encryption, participating in multi-party secure computation protocols, or loading computational logic in a trusted execution environment.

[0031] Throughout the execution process, the system's monitoring module continuously and objectively collects actual performance metrics data from each organization. This is a crucial type of log-based electronic data, reflecting the true physical execution status of each organization's computing nodes. For example, the monitoring module records the actual completion timestamp of each subtask, actual resource consumption (including CPU cycles and memory usage), network I / O traffic, and information such as whether the specified privacy channel scheme was strictly followed, and whether there were any mid-process exits or abnormal results.

[0032] Step 105: Based on the actual execution behavior indicator data, update the trust state to obtain the federation trust state vector, and generate privacy mode upgrade strategy data based on the federation trust state vector. Then, output the privacy mode upgrade strategy data to the medical institution or store it in the system database for subsequent privacy computing tasks.

[0033] The system's trust update module (executed by the processor) performs this step after the task is completed. First, the processor retrieves the actual performance indicator data collected in step 104 from storage and compares it with the expected cost or expected time used in the game modeling in step 103, generating a summary of performance data that quantifies the performance deviations of each institution.

[0034] The processor objectively adjusts the trust score of each institution based on the behavior performance summary data combined with the historical trust state, for example, institutions that perform better than expected increase their trust score, and vice versa, thereby calculating an updated alliance trust state vector. The processor generates a privacy mode upgrade strategy data based on this latest alliance trust state vector.

[0035] For example, for institutions with improved trust levels, the strategy may open more efficient privacy channels (privacy mode upgrade); for institutions with declining trust levels, the strategy may tighten the available channel set (privacy mode downgrade). This step forms a behavior-trust-path selection adaptive closed loop for the system.

[0036] In this embodiment, a medical data security sharing and privacy computing intelligent management system integrating game theory is also provided to support the above method.

[0037] The system is applied to multiple medical institutions, and the system can include hardware resources deployed on a server or cloud platform, such as a central processing unit (CPU), a graphics processing unit (GPU), a memory (such as a RAM, a hard disk), and a network interface. The memory stores computer executable instructions that, when executed by the processor, cause the processor to implement the following functional modules:

[0038] An initialization module for obtaining alliance institution basic configuration data and historical behavior audit data, and constructing a privacy mechanism capability directory and calculating an initial trust state vector.

[0039] A path modeling module for receiving privacy computing task request data, parsing the task to generate a multi-channel privacy path candidate set.

[0040] A game solving module for constructing and solving a heterogeneous privacy path selection game based on the path candidate set and the trust vector, and deriving a task privacy execution path plan.

[0041] An execution collection module for scheduling institution execution according to the execution plan and objectively collecting actual execution behavior indicator data.

[0042] A trust updating module for updating the trust state according to the actual behavior indicator data and generating privacy mode upgrade strategy data.

[0043] Embodiment 2 describes how to construct a task function dependency graph from a task request and how to quantitatively evaluate privacy risk parameters.

[0044] Step 201, decompose the privacy computing task request data to construct a task function dependency graph containing multiple subtask nodes.

[0045] As in Example 1, the processor of the system receives a structured privacy computation task request data. In this embodiment, the processor is internally configured with a pre-defined task decomposition rule base, which stores the mapping of different target analysis types to their standard computation steps in the form of, for example, key-value pairs. For example, for a federated logistic regression task, the rule base decomposes it into a series of sub-tasks such as feature extraction, local gradient computation, gradient secure aggregation, model parameter update, etc.

[0046] The processor utilizes this rule base to decompose the received task request into a list of sub-tasks. At the same time, the processor analyzes the input-output relationship, i.e. data dependency, among these sub-tasks. For example, local gradient computation must follow feature extraction, and gradient secure aggregation must follow local gradient computation. Based on these dependencies, the processor constructs and stores a task functional dependency graph data in memory. This data is a directed acyclic graph (DAG) data structure, where the nodes of the graph are the sub-tasks, and the directed edges of the graph represent the data flow and execution order among the sub-tasks.

[0047] At step 202, for any sub-task node in the task functional dependency graph, the processor matches feasible privacy channel schemes to it, in combination with the privacy mechanism capability catalog, including local differential privacy channel, cross-institution homomorphic encryption channel, cross-institution secure multi-party computation channel, or trusted execution environment channel, and estimates the channel cost and privacy risk parameters of the privacy channel scheme.

[0048] In this embodiment, the processor will then traverse each sub-task node in the task functional dependency graph generated in step 201. For any sub-task node, the processor will query the privacy mechanism capability catalog constructed in Example 1 to determine which privacy channel schemes can be used to execute the sub-task.

[0049] These feasible privacy channel schemes are diverse, and the processor will list a feasible channel list according to the type of the sub-task, such as local computation or cross-institution aggregation, and the support of the capability catalog. For example, for a local gradient computation sub-task, the feasible schemes can include local differential privacy channel (noise in local) or trusted execution environment channel (compute in TEE). For a gradient secure aggregation sub-task, the feasible schemes can include cross-institution homomorphic encryption channel (upload ciphertext by each party, and decrypt the sum by the aggregation party) or cross-institution secure multi-party computation channel (compute the sum by each party collaboratively, without anyone knowing the individual value).

[0050] While listing the feasible channel schemes, the processor must estimate the channel cost and the channel privacy risk parameter for each subtask-channel combination. The estimation of the channel cost is based on the objective resource indicators in the capability catalogue, for example, the processor will estimate the estimated computation delay, network bandwidth consumption and computation resource consumption (CPU cycles) of the channel scheme.

[0051] The estimation of the channel privacy risk parameter is more complex, which is a quantitative score, and its calculation process is described in detail in step 203.

[0052] Step 203, estimating the channel privacy risk parameter, includes: evaluating the data type sensitivity score of the data processed by the subtask node; obtaining the differential privacy parameter corresponding to the privacy channel scheme and the channel inherent leakage risk score; based on the weighted combination of the data type sensitivity score, the function of the differential privacy parameter, and the channel inherent leakage risk score, the channel privacy risk parameter is calculated.

[0053] This step describes the privacy risk quantification process in detail. When performing this calculation, the processor uses a multi-factor weighting model. In a preferred embodiment, the privacy risk score risk_task_channel for a certain subtask and a specific channel scheme combination can be calculated by the following pure text formula:

[0054] risk_task_channel=γ_sensitivity*sensitivity_score+γ_dp*f_dp(ε_task,δ_task)+γ_channel*channel_leakage_score+γ_composition*log(1+query_depth)

[0055] Wherein, the meaning and acquisition method of each parameter in the formula are as follows:

[0056] sensitivity_score is the data type sensitivity score. The processor evaluates the sensitivity of the data type processed by the subtask according to a pre-set sensitivity rule library. For example, the rule library can stipulate that the score of genetic data is 0.9, the score of mental illness diagnosis data is 0.8, and the score of regular statistical data is 0.2.

[0057] ε_task and δ_task are the differential privacy parameters adopted by the channel scheme. If the channel does not adopt differential privacy, this item can be 0 or other equivalent risk measures.

[0058] f_dp(ε_task, δ_task) is a function of differential privacy parameters, which is used to map DP parameters into a function of risk contribution. For example, f_dp can be simply taken as ε_task, because in differential privacy, the smaller the ε, the better the privacy protection and the lower the risk (in this model, for the sake of simplicity of description, it is assumed that f_dp is proportional to risk, or in actual application, the f_dp function will be appropriately transformed).

[0059] channel_leakage_score is the channel inherent leakage risk score, which is used to evaluate whether the security model of the privacy channel itself has the risk of side channel leakage, etc. For example, a channel based on ideal secure multi-party computation may have a lower score (such as 0.1); and a TEE channel relying on hardware may have a slightly higher score (such as 0.3) if potential side channel attacks are considered; and a local differential privacy channel may have a relatively high score (such as 0.5) due to the possible exposure of intermediate statistical results.

[0060] query_depth represents the query chain depth or cumulative query number of the current subtask in the entire task dependency graph, which is used to reflect the risk accumulation brought by the combination of privacy budgets. log(1+query_depth) is an exemplary combination risk measurement method.

[0061] γ_sensitivity, γ_dp, γ_channel, and γ_composition are preset non-negative weight coefficients for adjusting the proportion of different risk factors in the total score, and the sum of all weights can be normalized to 1.

[0062] By performing this calculation, the processor associates an objective, comparable channel privacy risk parameter value with each subtask-channel combination.

[0063] Step 204, combine the privacy channel schemes of each subtask node in the task function dependency graph to form a multi-channel privacy path candidate set.

[0064] After the processor completes the estimation of the cost and privacy risk of all feasible channels of all subtasks (such as step 203), this step is entered. The processor enumerates or searches all possible complete path combinations on the data structure of the task function dependency graph DAG in topological order from the task input node to the task output node.

[0065] Each complete path combination selects a specific privacy channel scheme for each subtask node in the graph. The processor calculates the cumulative execution cost of the complete path, e.g. summing or taking the maximum of the cost of all subtasks in the path, and the cumulative privacy risk, e.g. summing or other aggregating the risk scores risk_task_channel of all subtasks in the path.

[0066] Finally, the processor organizes and stores all these evaluated complete path combinations and their corresponding cumulative costs and cumulative privacy risks in memory, forming a multi-channel privacy path candidate set. This set data will be the main input of step 103 (game solving) in embodiment 1, for the game module to make decisions among these candidates.

[0067] Embodiment 3, quantitative calculation method of trust state vector and update mechanism of trust-behavior closed loop.

[0068] Step 301, calculating the initial trust state vector and updating the trust state to obtain the alliance trust state vector, includes: extracting historical behavior indicators from historical behavior audit data or actual execution behavior indicator data, the historical behavior indicators at least including: compliance violation proportion, on-time task completion proportion, and audit quality score; performing weighted combination on the historical behavior indicators to calculate a normalized trust score; taking the trust score as the core component of the initial trust state vector or the alliance trust state vector.

[0069] In this embodiment, this step is performed in two stages: one is in step 101 of embodiment 1, the processor calculates the initial trust state vector based on historical behavior audit data, i.e. the long-term objective performance log since the institution joined the alliance; the other is in step 105 of embodiment 1, the processor updates the trust state based on actual execution behavior indicator data, i.e. the objective performance log of the latest task just completed.

[0070] The historical behavior indicators include quantitative indicators extracted by the processor from the objective log data. For example, the compliance violation proportion is an objective proportion calculated by the processor by counting the number of times of data leakage, result rejection for acceptance, or non-compliance with the specified channel in historical tasks divided by the total number of tasks; the on-time task completion proportion is an objective proportion calculated by the processor by counting the number of times of on-time submission of results divided by the total number of tasks; the audit quality score can be the average quality score of the historical submission results of the institution by the platform administrator or the automatic audit tool.

[0071] In a preferred embodiment, the system calculates a normalized trust score trust_score(i) for each medical institution i as the core component of the trust state vector. The calculation is performed by the processor and can use the following pure text linear weighting formula:

[0072] trust_score(i) = w1 * (1 - violation_rate(i)) + w2 * on_time_ratio(i) + w3 * audit_score(i) + w4 * participation_score(i);

[0073] wherein violation_rate(i) is the compliance violation rate; on_time_ratio(i) is the on-time task completion rate; audit_score(i) is the audit quality score; participation_score(i) is an optional indicator representing the score of the degree of participation of institution i in past tasks (e.g., the frequency of participation or the degree of contribution); w1, w2, w3, w4 are preset non-negative weight parameters for adjusting the influence of different dimensions on the trust score, and the sum (w1 + w2 + w3 + w4) is equal to 1. These weights can be configured by the alliance management platform according to regulatory requirements.

[0074] After the processor performs this calculation, the resulting trust_score(i) is a normalized value between 0 and 1. The processor combines this score with other auxiliary components into a data vector as the core component of the initial trust state vector or the alliance trust state vector, and updates it to the memory for subsequent steps (such as embodiment 4) to call.

[0075] Optionally, when storing the trust state vector, in addition to the core trust_score(i) score, some auxiliary components such as the total number of violations, the number of consecutive on-time task completion rounds, and other raw indicators can be recorded for more detailed trust trajectory analysis and audit. In another optional implementation, the trust score calculation formula can also use a more complex nonlinear model, for example, introducing a time decay factor so that recent behavior performance (such as the latest deviation analyzed in step 302) has a higher weight than early historical behavior, so that the trust update is more timely.

[0076] Step 302, according to the actual execution behavior index data, update the trust state to obtain the alliance trust state vector, and generate privacy mode upgrade strategy data based on the alliance trust state vector, including: obtaining the institution path revenue and cost estimation data generated for the medical institution in the heterogeneous privacy path selection game solving step, the institution path revenue and cost estimation data is calculated based on the multi-channel privacy path candidate set; compare the actual execution behavior index data with the institution path revenue and cost estimation data, generate behavior performance summary data containing expected cost and actual cost deviation and expected completion time and actual completion time deviation; adjust the historical trust state based on the behavior performance summary data to obtain the updated alliance trust state vector; and generate privacy mode upgrade strategy data according to the updated alliance trust state vector.

[0077] A closed-loop feedback mechanism is described, that is, the processor performs the following operations in this step: first, the processor reads two types of data from the memory: the first type is the institution path revenue and cost estimation data, which is generated in step 103 (game solving) of embodiment 1, which is the system's estimate of the cost and time the institution should pay in this task; the second type is the actual execution behavior index data, which is objectively collected in step 104 (execution collection) of embodiment 1, which is the actual value of the institution in the physical execution process (for example, the actual consumed CPU time and network bandwidth, and the actual completion timestamp).

[0078] The processor compares the two types of data and calculates the deviation. For example, calculate the expected cost and actual cost deviation (cost_deviation = actual_cost - estimated_cost), and the expected completion time and actual completion time deviation (time_deviation = actual_time - estimated_time). The processor combines these calculated deviation values with other execution performance indicators (such as whether to comply with the selected channel scheme) into a structured behavior performance summary data and stores it in the log.

[0079] The processor adjusts the historical trust state based on the behavior performance summary data. This is an indirect adjustment, that is, the processor takes this behavior performance summary data as the latest input when calculating the trust score in the next execution step 301. For example, if the cost_deviation or time_deviation of an institution is consistently positive and exceeds the threshold, indicating that its performance is not as expected or there is resource lying, the system can dynamically reduce its audit quality score or increase its compliance violation rate when calculating its next round trust_score(i), resulting in a decrease in its total trust score.

[0080] The processor generates privacy mode upgrade strategy data according to the updated coalition trust state vector. After the trust score (trust_score(i)) is updated, the processor generates a privacy mode upgrade strategy data immediately or at the beginning of the next round of tasks. This data specifies the treatment that the institution should receive in the next round of games due to the change in trust, such as relaxing or tightening its available privacy channels. This strategy data will be used as a direct input to build game constraints in Embodiment 4, thus completing the complete closed loop of behavior-trust-strategy.

[0081] Embodiment 4 describes how to convert the trust state vector obtained in Embodiment 3 into specific and executable constraints on the game strategy space.

[0082] Step 401, based on the multi-channel privacy path candidate set and the initial trust state vector, construct and solve the heterogeneous privacy path selection game, and derive the task privacy execution path plan.

[0083] As in Embodiment 1, the processor models the path selection problem as a game process. In this embodiment, the participants of the game can specifically include:

[0084] A platform participant representing the overall interests of the coalition, such as pursuing the shortest total time and the lowest total risk,

[0085] Multiple medical institution participants representing their own local interests, such as pursuing the lowest own cost and the maximum research benefit. The strategy space of the game is defined by the multi-channel privacy path candidate set generated in Embodiment 2, i.e. each institution participant can choose to use which privacy channel scheme, such as HE, MPC, DP, to execute the subtask assigned to it. The utility function of the game defines the benefits or costs of each participant under different strategy combinations, which will be described in detail in Embodiment 5.

[0086] Before formally defining the strategy space and utility function of the game, the system performs a preprocessing step, i.e. using the trust state vector to impose constraints on the game.

[0087] Step 402, based on the initial trust state vector, convert and generate institution trust constraint parameter data, including: extracting the trust scores of each medical institution in the initial trust state vector; comparing the trust scores with the preset trust threshold, and classifying the medical institutions into different trust levels; according to the trust level, assigning a differentiated set of available privacy channels to the medical institution, and setting its upper limit of privacy parameters under local differential privacy channel as institution trust constraint parameter data.

[0088] In one example, the medical institutions are assigned with a set of differentiated available privacy computation channels according to the trust level and a preset level-parameter mapping rule, and an upper limit of privacy parameter of the medical institutions in the local differential privacy computation channel is set, and the set of available privacy computation channels and the upper limit of privacy parameter are taken as the institution trust constraint parameter data.

[0089] In the present embodiment, the processor performs this step. First, the processor reads the latest coalition trust state vector calculated in Embodiment 3 from the memory, and extracts the core trust score trust_score(i) of each institution i.

[0090] Then, the processor compares the trust score with a preset trust threshold. In a preferred embodiment, the processor uses a segmented mapping rule to divide the trust level. For example, the system can preset two thresholds: a low trust threshold trust_low_threshold (for example, 0.3) and a high trust threshold trust_high_threshold (for example, 0.7).

[0091] When trust_score(i) is less than or equal to 0.3, institution i is classified as a low trust level. According to this level, the differentiated available privacy channel set assigned to it will be strictly limited, for example, only allowing it to use the highest security level channel on high sensitivity sub-tasks, such as cross-institution homomorphic encryption channel or secure multi-party computation channel, and prohibiting it from using the local differential privacy channel independently. At the same time, the upper limit of the differential privacy parameter ε of it (if still needed to use DP on some non-sensitive tasks) is set to a very strict value ε_strict (for example, 0.1) to provide the highest strength of privacy protection.

[0092] When trust_score(i) is between 0.3 and 0.7, institution i is classified as a medium trust level. The processor will allow it to use the local differential privacy channel or the trusted execution environment channel on some medium sensitivity sub-tasks, and the upper limit of the differential privacy parameter ε of it is set to a medium value ε_medium (for example, 0.5).

[0093] When trust_score(i) is greater than or equal to 0.7, institution i is classified as a high trust level. The processor will reward the institution and allow it to use more computationally efficient and less costly privacy channels (for example, hybrid channel schemes with better performance or local differential privacy channels) on more sub-tasks under the premise of meeting regulatory requirements, and the upper limit of the differential privacy parameter ε of it is set to a relatively relaxed value ε_relaxed (for example, 1.0 or higher).

[0094] The processor generates an institution trust constraint parameter data for each institution by mapping the above (trust level -> available channel set + parameter upper limit). The data is a temporary data structure (for example, a lookup table or rule set) stored in memory, which will be used to actually constrain the game model in step 403.

[0095] In step 403, the path selection game modeling data is constructed, including: according to the institution trust constraint parameter data, when defining the strategy space, for the medical institution divided into the low trust level, imposing a penalty or performing strategy space reduction on the strategy of selecting the high-risk privacy channel; for the medical institution divided into the high trust level, giving an additional reward on the strategy of selecting the high-efficiency privacy channel.

[0096] In this step, the processor modifies the game according to the institution trust constraint parameter data just generated when constructing the game model (i.e., defining the participants, the strategy space, and the utility function).

[0097] One implementation is strategy space reduction, which is a hard constraint. When traversing the multi-channel privacy path candidate set in embodiment 2, the processor checks each path. If a path requires a low-trust-level institution i to perform a high-risk privacy channel, for example, using a local DP channel with ε>0.1, the processor determines that the path violates the institution trust constraint parameter data and immediately removes the path from the candidate set. In this way, the strategy space of the low-trust institution is physically reduced, so that it has no chance to select a high-risk strategy in the game.

[0098] Another implementation is to impose a penalty or give a reward, which is a soft constraint, implemented by modifying the utility function. For example, when a low-trust-level institution i tries to select a high-risk channel in the game, the system automatically introduces a large penalty term, for example, a large negative cost, when calculating its institution utility function, so that the utility of this strategy is much lower than that of selecting a safe channel. Conversely, when a high-trust-level institution i selects a high-efficiency (but possibly risky) channel, the system gives an additional reward in its utility function, encouraging such high-trust, high-efficiency behavior.

[0099] Through any of the above methods, the invention deeply couples the historical behavior of the institution with the construction of the game, ensuring that the solution process of the game is strictly constrained by the trust state.

[0100] In some alternative embodiments, the value of the penalty or reward can be dynamic, for example, its magnitude is proportional to the difference between the trust_score(i) score of the institution and the threshold, achieving a more smooth incentive and constraint. Further, the policy space reduction can not only be directed at the type of privacy channel, but also be refined to the specific parameters of the channel, for example, the selection range of the length of the cryptographic key, the redundancy of secure multi-party computation, is dynamically limited.

[0101] In this embodiment, when a cycle occurs, a mixed strategy or ε-equilibrium concept is adopted.

[0102] Embodiment 5, describes the definition and solving process of the utility function of the game model, to ensure that the game result can balance the global interest and the local interest.

[0103] Step 501, the utility function defined in the path selection game modeling data includes at least: a platform utility function, which is constructed considering the overall execution delay estimation, total cost estimation and privacy risk score of each path in the candidate set of multi-channel privacy paths; and an institution utility function, which is constructed considering the expected research income, institution cost, institution risk and trust reward of each medical institution under different paths.

[0104] In this embodiment, the processor defines different and formal utility functions for platform participants and institution participants when constructing the game model.

[0105] In a preferred embodiment, the platform utility function U_platform(path_p) is evaluated for each candidate path path_p in the candidate set of multi-channel privacy paths generated in Embodiment 2. The goal of this function is to minimize the global cost and risk (or maximize its negative value), which can be represented by the following pure text linear formula:

[0106] U_platform(path_p)=-α_latency*latency(path_p)-α_cost*total_cost(path_p)-α_risk*privacy_risk(path_p);

[0107] wherein latency(path_p) represents the total execution latency estimation of all sub-tasks under the path combination (e.g. the total length of the critical path); total_cost(path_p) represents the sum of the total cost estimation of computation and communication of all institutions under the path combination; privacy_risk(path_p) is the privacy risk score under the path combination (its calculation method has been elaborated in embodiment 2). The parameters a_latency, a_cost and a_risk are all preset non-negative weights set by the alliance platform, used to adjust the weights of latency, cost and privacy risk in the platform global utility.

[0108] Meanwhile, the processor defines the institution utility function U_inst(i, path_p) of each medical institution participant i, which aims to maximize the net income of the institution, and can be represented by the following pure text linear formula:

[0109] U_inst(i, path_p) = β_benefit * research_benefit(i, path_p) - β_cost * inst_cost(i, path_p) - β_risk * inst_risk(i, path_p) + β_trust * trust_reward(i, path_p);

[0110] wherein research_benefit(i, path_p) represents the expected research benefit that the institution i can obtain under the path combination, for example, quantified based on the sample size contributed by it or the contribution to the improvement of model accuracy; inst_cost(i, path_p) represents the institution cost of institution i under the path combination, i.e. the computation cost and communication cost it needs to bear itself; inst_risk(i, path_p) represents the institution risk score of the path combination to the patient data controlled by institution i; trust_reward(i, path_p) is the trust reward detailed in step 502; and the parameters β_benefit, β_cost, β_risk and β_trust are non-negative weights set by institution i itself (or set uniformly by the platform), used to adjust the preferences of the institution between benefits, costs, risks and trust rewards.

[0111] The trust reward contained in the institution utility function in step 502 is defined as: when the medical institution actively selects a privacy channel scheme with a higher security level than the baseline requirement in path selection, it is allocated a trust reward score.

[0112] This step is a detailed description of the trust reward item trust_reward(i, path_p) in step 501. Relative to the hard constraint in embodiment 4, i.e. policy space reduction, this mechanism acts as a soft constraint incentive. The benchmark requirement can refer to meeting regulatory compliance or the minimum security requirement corresponding to the trust level in embodiment 4. When an institution (especially an institution with a medium or high trust level) actively selects a privacy channel scheme with higher security (for example, with higher computational cost) in game decision-making, for example, the benchmark requirement is DP, but the institution actively selects MPC, the system processor will assign a positive trust_reward(i, path_p) score to it when calculating its U_inst. This is designed to encourage high-trust institutions to take more security responsibility through the design of the utility function, offsetting the increased inst_cost due to the selection of a safer scheme, thereby guiding the game to evolve towards a safer and more trustworthy equilibrium state.

[0113] Step 503, solving the path selection game modeling data, using an iterative optimal response algorithm, including: initializing the path selection strategy configuration; in the iteration process, for any medical institution, fixing the channel selection strategy of other medical institutions, calculating and selecting the best response strategy that maximizes the utility of the medical institution itself based on the institution utility function; updating the path selection strategy configuration using the best response strategy; iterating until the path selection strategy configuration converges or reaches the preset iteration upper limit, and taking the convergence result as the path selection strategy configuration data.

[0114] In this embodiment, after the processor builds the game model containing the utility functions of steps 501 and 502, it needs to execute a solving algorithm to find the equilibrium solution. A preferred and implementable algorithm is the iterative optimal response algorithm, the specific execution process of which is implemented by the processor:

[0115] The processor performs initialization of the path selection strategy configuration. For example, for each subtask node in the task function dependency graph, a channel scheme is randomly selected from the feasible channel list generated in embodiment 2 (which has been filtered by the trust constraint in embodiment 4) to form an initial, complete path selection strategy configuration.

[0116] The processor enters an iterative process. In each round of iteration, the processor sequentially (or in parallel) for each medical institution participant i: fixes the channel selection strategy of all other institutions j (j not equal to i) unchanged; the processor traverses all feasible channel scheme combinations of institution i on all its participating sub-tasks (i.e. its strategy space under the constraints of embodiment 4); based on the institution utility function U_inst(i, path_p) defined in step 501, the processor calculates the expected utility value of institution i under each feasible scheme combination; the processor selects the channel scheme combination that maximizes U_inst(i, path_p) as the best response strategy of institution i in the current round.

[0117] The processor updates the current path selection strategy configuration with the best response strategy of institution i.

[0118] The processor repeats the above iteration until the path selection strategy configuration converges, i.e. in consecutive rounds of iteration, the best response strategy of no institution has changed, at which point the system reaches a Nash equilibrium or an approximate equilibrium state; or, the iteration process reaches the preset upper limit of the number of iterations (e.g. 500 rounds) to prevent excessive solution time.

[0119] The processor takes the stable path selection strategy configuration obtained at the end of iteration as the final game solution result and outputs it as path selection strategy configuration data.

[0120] Step 504, generating a task privacy execution path plan according to the path selection strategy configuration data.

[0121] This is the last step of game solving. The processor obtains the path selection strategy configuration data output in step 503 (which may be an internal data structure, such as a mapping table, indicating the final selected channel scheme for each sub-task node). The processor remaps this configuration data back to the data structure of the task function dependency graph constructed in embodiment 2, explicitly specifying the unique execution mode for each node in the graph. In this way, the processor generates a complete, specific, and concrete task privacy execution path plan from task input to task output. This plan is a structured instruction data that will be sent to the execution collection module of embodiment 6 to guide joint privacy computation in the physical world.

[0122] Embodiment 6 describes how to put the task privacy execution path plan into physical execution and how to objectively collect data.

[0123] Step 601, scheduling medical institutions to perform joint privacy computation according to the task privacy execution path plan.

[0124] In this embodiment, the system’s execution collection module (implemented by one or more processors) receives the task privacy execution path plan generated in embodiment 5 from the memory. This module parses this plan and translates it into a series of specific control instructions and scheduling signals.

[0125] The processors distribute these control instructions to the computing nodes of various medical institutions in the alliance (e.g., servers or virtual machines deployed within the institution’s firewall) through the network interface. After receiving the instructions, the computing nodes of each institution load the corresponding computing programs and cryptography components according to the roles and privacy channel schemes specified in the plan, and begin to perform joint privacy computation.

[0126] For example, if the task privacy execution path plan specifies that a certain subtask uses a cross-institution homomorphic encryption channel scheme: the processors schedule the computer nodes of the data holders (e.g., institutions A and B) to execute local data encryption programs, and send the encrypted local results to a designated aggregation node through the network interface; at the same time, the processors schedule the computer of the aggregation node to perform ciphertext aggregation operations, and (if necessary) execute decryption programs to obtain the final aggregation result.

[0127] For another example, if the plan specifies the use of a secure multi-party computation channel scheme: the processors schedule the computer nodes of institutions A and B to simultaneously load and execute a secure multi-party computation protocol, such as a secret sharing-based addition protocol; these nodes interact with each other through the network under the coordination of the processors, and finally each obtains the computation result or result share without exposing the original data.

[0128] For another example, if the plan specifies the use of a local differential privacy channel scheme: the processors schedule the computer nodes of institution A to calculate statistical results locally, then call a differential privacy library to add noise to the results using the ε parameter (e.g., ε_medium) determined by the trust level in embodiment 4, and then send the noisy results to the data demander through the network.

[0129] Step 602, and collect actual execution behavior indicator data.

[0130] During the entire process of processor scheduling execution computation in step 601, a monitoring module of the system will concurrently, continuously, and objectively record the actual execution performance of the computing nodes of each institution.

[0131] The actual execution behavior indicator data is objective electronic data collected and stored in the log database by the monitoring module. These data must be quantifiable and verifiable to reflect the true running state of the computer. Specifically, this data at least includes:

[0132] Actual completion time: The monitoring module calculates the actual physical time consumption by recording the system clock timestamps of the task start and end. Actual resource consumption: The monitoring module obtains the objective physical resource indicators of the task, such as CPU cycles, memory peaks, network I / O throughput, etc., by querying the operating system kernel or virtualization layer. Compliance with the scheme: The monitoring module analyzes the communication log or protocol handshake information to determine whether the institution strictly follows the specified channel scheme (such as the specified encryption algorithm, key length, or differential privacy parameter) in the task privacy execution path plan.

[0133] After the task is completed, the processor packages and archives these objectively collected actual execution behavior indicator data. As in step 302 of embodiment 3, these data will be the only basis for calculating deviations (compared with expected values) and updating trust state vectors, thus constituting the physical data basis of the technical closed loop of the present application.

[0134] It should be noted that, in order to more clearly understand the technical concept and protection scope of the present application, the specific meanings of the upper concepts involved in the present application are clarified:

[0135] Privacy mechanism: In the present application, it refers to an abstract, underlying technical capability or technical type. It is usually defined and listed in the privacy mechanism capability directory, for example, an institution has the capability of homomorphic encryption or supports secure multi-party computation mechanism. It answers the question of what can be done.

[0136] Privacy channel: In the present application, it refers to a specific, game-selectable execution path or instance. It is the basic component unit of the multi-channel privacy path candidate set, and is also the selectable action or strategy of the game process. For example, the aggregation task performed by institutions A and B using the homomorphic encryption scheme is a channel. It answers the question of which scheme to choose.

[0137] Privacy mode: In the present application, it refers to a macroscopic strategy configuration or running state based on dynamic adjustment of trust division. It is usually the output result of the privacy mode upgrade strategy, and serves as the input of the game constraint (for example, the trust level-channel mapping rule). For example, in the low-trust mode, the local differential privacy channel option may be prohibited by the privacy mode strategy. It answers the question of what to allow to choose.

[0138] In summary, the present application dynamically regulates the availability and cost of privacy channels through privacy mode, and the evolution of privacy mode depends on the objective audit of the historical behavior of each institution, thereby realizing a self-adaptive privacy computing management closed loop based on trust evolution.

[0139] Embodiment 7, computer-implemented process for describing game solution termination conditions.

[0140] In the present embodiment, the process of iterating until the path selection strategy configuration converges or reaches a preset iteration upper limit is implemented by a dedicated monitoring and control loop by the processor of the game solving module, which is closely related to the internal state and resource consumption of the computer.

[0141] Specifically, the processor performs a convergence check calculation immediately after each iteration, for example, after updating the best response strategy of all agencies i. For this purpose, the processor keeps the path selection strategy configuration of the last iteration (K-1) in the memory, for example, the strategy configuration can be a vector or a hash table containing the selection of all subtask channels. The processor compares the configuration (configuration K-1) with the path selection strategy configuration (configuration K) generated in the current iteration (K). The comparison is a specific calculation operation, for example, the processor calculates the Hamming distance between the two configuration vectors, that is, how many subtask selections have changed, or calculates whether the hash value of the configuration data in the memory has changed, thereby obtaining a quantitative change amplitude. The processor compares the change amplitude with a preset convergence threshold stored in the system configuration, for example, the threshold is 0, indicating that the strategy does not change at all.

[0142] At the same time, the processor starts an internal counter or timer before starting the iteration process to monitor the computing resources consumed by the iteration process. In one embodiment, the resource is the number of iteration rounds. The processor increments a counter stored in the memory by 1 at the beginning of each iteration. In another embodiment, the resource is the processor execution time. The processor records a start timestamp at the beginning of the iteration and obtains the current timestamp after each iteration to calculate the total physical time consumed.

[0143] At the end of each iteration, the processor performs a termination logic judgment based on the above calculation and monitoring results. When at least one of the following conditions is met, the processor will immediately terminate the iteration process. The conditions include: the change amplitude is lower than the preset convergence threshold, or the number of iteration rounds exceeds the preset resource upper limit (iteration upper limit), or the processor execution time exceeds the preset resource upper limit (timeout time), for example, 3000 milliseconds.

[0144] When the iteration is terminated, the processor releases the temporary memory resources used for iteration calculation, and marks the path selection strategy configuration of the current round K as the final solving result and stores it in the memory for subsequent steps of generating a task privacy execution path plan. This double termination condition based on the internal computing state (change amplitude) and physical resource consumption (round number or time) of the computer ensures that the game solving process can be efficiently terminated when a stable solution is found, and can avoid unlimited occupation of processor resources when the solution space is too large or trapped in oscillation, ensuring the responsiveness and stability of the system.

[0145] According to an aspect of the present application, the input data is an electronic record of objective physical events or states, which is the starting point of the present technical solution.

[0146] For example, the historical behavior audit data acquired in the initialization step is such input. This data is not subjective fabrication, but a faithful record of objective physical events. Specifically, the proportion of tasks completed on time indicator contained in this data is originally based on the calculation of two objective physical time points by the system processor: one is the task deadline timestamp (e.g., 2025-11-14T08:00:00Z), which is a physical time point defined by the system clock; the other is the actual submission timestamp (e.g., 2025-11-14T07:58:29Z), which is another physical time point recorded by the system clock when it receives the data packet submitted by the institution. Similarly, the compliance violation proportion indicator is based on the analysis of system log files, which objectively record computer network communication and program execution status, such as recording events such as 2025-11-13T10:30:05Z - Institution B - Error: Occurred in the middle of the exit or the result is abnormal, etc.

[0147] As another example of input data, the federation institution base configuration data is also an electronic description of objective physical resources. For example, the configuration data of an institution can be a JSON entry, such as: {"institution_id":"Hospital_A","supports_HE":true,"supports_MPC":false,"network_bandwidth_mbps":1000,"compute_cost_factor":0.8}. The network_bandwidth_mbps:1000 in this data is a quantitative description of the objective throughput capacity of its network interface (a kind of physical communication device), and supports_HE:true is an objective state record of whether its processor or software stack has a specific cryptographic operation capability.

[0148] For another example, the privacy computing task request data is also an input data, which is an electronic data packet with a specific format sent by the upper application to the present system through the network interface, such as: {"task_type":"federated_logistic_regression","precision_requirement":"0.001","time_urgency":"high"}. This data is the trigger of the present technical process.

[0149] Intermediate data is electronic data structure stored in memory, generated by processor based on objective input data, through specific technical rules defined in the invention, such as algorithm, formula or mapping rule, with specific technical meaning, used to control subsequent technical steps.

[0150] For example, the processor calculates the above-mentioned objective timestamp comparison result and system log through the trust score weighting formula, and converts it into a normalized floating-point value stored in memory, i.e. trust score, such as 0.82. This is a typical intermediate data (intermediate data A).

[0151] The trust score (intermediate data A) will be used as input for the next calculation step. The processor further processes it according to the defined segmented mapping rule, and converts it into a set of institutional trust constraint parameter data. This is a more complex intermediate data (intermediate data B), such as a lookup table or rule set stored in memory, for example: {"trust_level":"high","allowed_channels":["HE","MPC","local_DP"],"ε_limit":1.0}. This intermediate data is used technically to directly constrain the strategy space of the subsequent game solving step.

[0152] Other examples of intermediate data also include task function dependency graph data, which is a directed acyclic graph DAG data structure constructed in the processor memory, for example, it may represent:

[0153] [Node_A:'feature_extraction']->[Node_B:'local_gradient_compute']->[Node_C:'secure_aggregation']. This data is generated by the processor to parse the input data task request, and is used to build the skeleton of the entire computing process.

[0154] For example, the multi-channel privacy path candidate set is also a key intermediate data. It is a complex list data structure generated by the processor in combination with the task function dependency graph (intermediate data) and the privacy mechanism capability catalog (intermediate data transformed from input data). For example, the list can contain: [{path_id: 1, steps: [Node_A: 'local_DP', Node_B: 'local_DP', Node_C: 'HE_aggregation'], total_risk: 0.85, total_cost: 120}, {path_id: 2, steps: [Node_A: 'TEE', Node_B: 'TEE', Node_C: 'MPC_aggregation'], total_risk: 0.45, total_cost: 450}]. This intermediate data is the direct input of the subsequent game solving step (i.e., the strategy space of the game).

[0155] Output data is control instruction data used to control one or more computer physical resources (such as processors, network interfaces) to perform specific technical tasks. It is not abstract information for human reading, but data with clear technical meaning for driving machine execution.

[0156] For example, the task privacy execution path plan finally generated in the game solving step is such output data. The plan is the unique solution selected by the processor from the multi-channel privacy path candidate set (intermediate data) through iterative optimal response algorithm calculation. It is a specific, structured instruction data, for example, a JSON object: {"task_id": "T123", "global_plan": [{step: 'Node_A', exec_channel: 'TEE', participants: ['Hospital_A', 'Hospital_B']}, {step: 'Node_B', exec_channel: 'TEE', participants: ['Hospital_A', 'Hospital_B']}, {step: 'Node_C', exec_channel: 'MPC_aggregation', participants: ['Hospital_A', 'Hospital_B'], params: {protocol: 'SecureSum'}}]}.

[0157] When this output data is read and parsed by the processor of the collection module in subsequent computation execution and collection steps, it is translated into a series of direct control signals to physical hardware. For example, the entry {step: 'Node_C', exec_channel: 'MPC_aggregation',...} in the above data will directly cause the processor to: (a) send control signals to the computation nodes located at 'Hospital_A' and 'Hospital_B' through the network interface; (b) instruct the processors of these servers to load and execute the secure multi-party computation protocol software named 'SecureSum'; (c) command the network interfaces of these servers to establish encrypted connections on specific ports to start the multi-round data interaction required for the multi-party protocol.

[0158] In one scenario, assume that the alliance contains three medical institutions, namely, institution A (a large three-A hospital), institution B (a medium-sized specialized hospital), and institution C (a community hospital newly joined in the alliance). The system reads the historical behavior audit data of each institution from the memory, where the historical data of institution A shows that the compliance violation rate is 0.02, the on-time task completion rate is 0.96, the audit quality score is 0.91, and the participation score is 0.88; the historical data of institution B shows that the compliance violation rate is 0.15, the on-time task completion rate is 0.78, the audit quality score is 0.72, and the participation score is 0.65; and the historical data of institution C shows that the compliance violation rate is 0.28, the on-time task completion rate is 0.62, the audit quality score is 0.55, and the participation score is 0.42.

[0159] The processor calculates using the trust score formula, where each weight parameter is set as w1 equal to 0.30, w2 equal to 0.30, w3 equal to 0.25, and w4 equal to 0.15.

[0160] For institution A, the processor calculates the trust score as:

[0161] trust_score(A) = 0.30 x (1 - 0.02) + 0.30 x 0.96 + 0.25 x 0.91 + 0.15 x 0.88 = 0.85.

[0162] For institution B, the processor calculates the trust score as:

[0163] trust_score(B) = 0.30 x (1 - 0.15) + 0.30 x 0.78 + 0.25 x 0.72 + 0.15 x 0.65 = 0.45.

[0164] For institution C, the processor calculates the trust score as:

[0165] trust_score(C) = 0.30 x (1 - 0.28) + 0.30 x 0.62 + 0.25 x 0.55 + 0.15 x 0.42 = 0.25.

[0166] The processor combines the above three scores into an initial trust state vector, denoted as vector (0.85, 0.45, 0.25).

[0167] After the system receives a federal logistic regression task request, the processor decomposes the task into three sub-task nodes according to the task decomposition rule library. The first sub-task is local feature extraction and gradient calculation, which is independently executed by each agency. The second sub-task is cross-institutional gradient secure aggregation, which requires multi-agency collaboration. The third sub-task is model parameter update and distribution, which is executed by the aggregation party and the results are returned to each agency. The task function dependency graph constructed by the processor is in a linear structure, i.e. the first sub-task points to the second sub-task, and the second sub-task points to the third sub-task.

[0168] For each sub-task node in the task function dependency graph, the processor generates feasible privacy channel schemes in combination with the privacy mechanism capability directory. For the first sub-task, feasible channel schemes include local differential privacy channel (denoted as DP, where the privacy parameter ε needs to satisfy the upper limit constraint) and trusted execution environment channel (denoted as TEE). For the second sub-task, feasible channel schemes include homomorphic encryption aggregation channel (denoted as HE) and secure multi-party computation channel (denoted as MPC). For the third sub-task, feasible channel schemes include TEE channel and HE channel.

[0169] The processor generates agency trust constraint parameter data according to the initial trust state vector. The trust score of agency A is 0.85, which is greater than the high trust threshold of 0.70, so it is classified as a high trust level, its available privacy channel set includes four channels of DP, TEE, HE and MPC, and the upper limit of privacy parameter ε when using DP channel is set to 1.0. The trust score of agency B is 0.45, which is between the low trust threshold of 0.30 and the high trust threshold of 0.70, so it is classified as a medium trust level, its available privacy channel set includes three channels of TEE, HE and MPC, and the upper limit of privacy parameter ε when using DP channel is set to 0.5. The trust score of agency C is 0.25, which is less than the low trust threshold of 0.30, so it is classified as a low trust level, its available privacy channel set only includes two channels of HE and MPC, and independent use of DP channel is prohibited.

[0170] The processor combines the feasible channel schemes of each sub-task and applies trust constraints for filtering, finally generating a multi-channel privacy path candidate set. The set contains four candidate paths.

[0171] The first path is: the first subtask adopts the DP channel, the second subtask adopts the HE channel, and the third subtask adopts the HE channel. The cumulative cost estimation of this path is 85 units, and the cumulative privacy risk score is 0.72.

[0172] The second path is: the first subtask adopts the DP channel, the second subtask adopts the MPC channel, and the third subtask adopts the TEE channel. The cumulative cost estimation of this path is 120 units, and the cumulative privacy risk score is 0.58.

[0173] The third path is: the first subtask adopts the TEE channel, the second subtask adopts the HE channel, and the third subtask adopts the HE channel. The cumulative cost estimation of this path is 145 units, and the cumulative privacy risk score is 0.45.

[0174] The fourth path is: the first subtask adopts the TEE channel, the second subtask adopts the MPC channel, and the third subtask adopts the TEE channel. The cumulative cost estimation of this path is 180 units, and the cumulative privacy risk score is 0.32.

[0175] Since the institution C is restricted from using the DP channel, the processor has automatically excluded or imposed a high penalty on the scheme involving the DP channel participated by the institution C when generating the candidate paths. Therefore, the subtask part executed by the institution C in the above four paths adopts the HE or MPC channel.

[0176] The processor constructs a game model and solves it using the iterative optimal response algorithm. In this game, the weight parameters of the platform utility function are set as α latency equal to 0.3, α cost equal to 0.4, and α risk equal to 0.3. The weight parameters of the utility function of each institution are set as β benefit equal to 0.35, β cost equal to 0.30, β risk equal to 0.25, and β trust equal to 0.10.

[0177] The game iteration process is as follows. In the initialization stage, the processor randomly selects the first path as the initial strategy configuration. In the first iteration round, the processor fixes the strategies of agencies B and C, calculates the agency utility value of agency A under the four paths, and agency A selects the third path as the best response; then the processor fixes the strategies of agencies A and C, calculates the best response of agency B, and agency B also selects the third path; finally the processor calculates the best response of agency C, and since agency C is not involved in the DP channel under the third path and the cost is moderate, agency C also selects the third path. After the first iteration round, the strategy configuration is updated to the third path. In the second iteration round, the processor repeats the above process to calculate the best response of each agency under the current configuration, and the result shows that the best response of each agency remains unchanged at the third path. The processor detects that the change amplitude of the strategy configuration is zero, determines that the game has converged, and terminates the iteration.

[0178] After the game is solved, the processor outputs the task privacy execution path plan. The plan specifies that the first subtask is executed by each agency locally using the TEE channel to perform feature extraction and gradient calculation; the second subtask is executed by agencies A and B as the main participants and agency C as the auxiliary participant using the HE channel to perform cross-institution gradient secure aggregation; and the third subtask is executed by the aggregation node using the HE channel to perform model parameter update and then distributed to each agency. The expected total cost of this execution plan is 145 units, and the expected privacy risk score is 0.45.

[0179] In summary, to address the problem that static strategies cannot dynamically constrain agency behavior, the present application constructs a behavior-trust closed loop. By quantifying the historical objective performance of agencies (such as the violation rate) to generate a trust score, and using this score to dynamically constrain their strategy space in the game: low-trust agencies are restricted to use high-risk channels, and high-trust agencies are encouraged to use efficient channels. This addresses the problem of inverted incentives and constraints under a one-size-fits-all strategy.

[0180] To address the problem of coarse granularity and homogenization of privacy technology selection in complex tasks, the present application proposes a heterogeneous privacy path game mechanism. This mechanism decomposes the task into a subtask graph, matches each node with a heterogeneous privacy channel (such as HE, MPC, TEE, etc.), and then solves it through game theory, selecting an optimal, fine-grained multi-technology combined path that takes into account both global utility and local cost, avoiding the efficiency bottleneck of a single technology path.

Claims

1. A method for intelligent management of medical data security sharing and privacy computing based on game theory, characterized in that, The method comprises the following steps: Obtain the alliance organization basic configuration data and historical behavior audit data of medical institutions, and construct a privacy mechanism capability directory and calculate an initial trust state vector based on the data; Receive privacy computing task request data, combine the privacy mechanism capability directory, analyze the task to generate a multi-channel privacy path candidate set; wherein the multi-channel privacy path is a complete execution path composed of matching feasible privacy computing channels for each subtask after the privacy computing task is decomposed into multiple subtasks; the multi-channel privacy path represents a specific technical implementation method from the beginning of the task to the end of the task, and the privacy computing channel includes a local differential privacy channel, a cross-institution homomorphic encryption channel, a cross-institution secure multi-party computing channel or a trusted execution environment channel; Based on the multi-channel privacy path candidate set and the initial trust state vector, construct and solve a heterogeneous privacy path selection game to derive a task privacy execution path plan; According to the task privacy execution path plan, schedule the medical institutions to perform joint privacy computing, and collect actual execution behavior index data; According to the actual execution behavior index data, update the trust state to obtain an alliance trust state vector, and generate a privacy mode upgrade strategy data based on the alliance trust state vector.

2. The method of claim 1, wherein, Based on the multi-channel privacy path candidate set and the initial trust state vector, construct and solve a heterogeneous privacy path selection game to derive a task privacy execution path plan, comprising: Based on the initial trust state vector, generate organization trust constraint parameter data; Combine the multi-channel privacy path candidate set and the organization trust constraint parameter data to construct path selection game modeling data, which defines the game participants, the strategy space and the utility function; Solve the path selection game modeling data to obtain path selection strategy configuration data; and generate a task privacy execution path plan according to the path selection strategy configuration data.

3. The method of claim 2, wherein, Based on the initial trust state vector, generate organization trust constraint parameter data, comprising: Extract the trust scores of each medical institution in the initial trust state vector; Compare the trust scores with the preset trust threshold to classify the medical institutions into different trust levels; According to the trust level, assign a differentiated set of available privacy computing channels to the medical institutions, and set the upper limit of the privacy parameters in the local differential privacy channel as the organization trust constraint parameter data.

4. The method of claim 2, wherein, Constructing path selection game modeling data, comprising: According to the organization trust constraint parameter data, when defining the strategy space, impose a penalty or reduce the strategy space for medical institutions classified as low trust level when they choose high-risk privacy computing channels; For medical institutions classified as high trust level, give additional rewards for their strategy of choosing high-efficiency privacy computing channels.

5. The method of claim 2, wherein, The utility function defined in the path selection game modeling data at least includes: A platform utility function, which is constructed by considering the overall execution delay estimate, total cost estimate and privacy risk score of each path in the multi-channel privacy path candidate set; An organization utility function, which is constructed by considering the expected research income, organization cost, organization risk and trust reward of each medical institution under different paths. The trust reward included in the institution utility function is configured to: when a medical institution actively selects a privacy computing channel with a higher security level than the baseline requirement in path selection, a trust reward score is assigned to the medical institution.

6. The method of claim 5, wherein, The path selection game modeling data is solved by using an iterative best response algorithm, including: initializing the path selection strategy configuration; in the iteration process, for any medical institution, fixing the channel selection strategy of other medical institutions, calculating and selecting the best response strategy that maximizes the utility of the medical institution itself based on the institution utility function; and updating the path selection strategy configuration by using the best response strategy; iterating until the path selection strategy configuration converges or reaches a preset iteration upper limit, and taking the converged result as the path selection strategy configuration data.

7. The method of claim 6, wherein, iterating until the path selection strategy configuration converges or reaches a preset iteration upper limit, specifically including: the processor calculates the change amplitude between the path selection strategy configuration of the current round and the path selection strategy configuration of the last round after completing each iteration in the iteration process; the processor monitors the computing resources consumed in the iteration process, and the computing resources at least include the iteration round number or the processor execution time; when the processor determines that the change amplitude is lower than a preset convergence threshold or the consumed computing resources exceed a preset resource upper limit, the processor terminates the iteration process.

8. The method of claim 1, wherein, According to the actual execution behavior index data, the trust state is updated to obtain a coalition trust state vector, and a privacy mode upgrade strategy data is generated based on the coalition trust state vector, including: obtaining the institution path revenue and cost estimation data generated for the medical institution in the heterogeneous privacy path selection game solving step; comparing the actual execution behavior index data with the institution path revenue and cost estimation data to generate behavior performance summary data including expected cost and actual cost deviation and expected completion time and actual completion time deviation; adjusting the historical trust state based on the behavior performance summary data to obtain an updated coalition trust state vector; and generating privacy mode upgrade strategy data according to the updated coalition trust state vector.

9. The method of claim 1, wherein, The initial trust state vector is calculated, and the trust state is updated to obtain a coalition trust state vector, including: extracting historical behavior indicators from historical behavior audit data or actual execution behavior index data, the historical behavior indicators including: compliance violation proportion, on-time task completion proportion, and audit quality score; performing weighted combination on the historical behavior indicators to calculate a normalized trust score; the trust score is used as a core component of the initial trust state vector or the coalition trust state vector.

10. A medical data security sharing and privacy computing intelligent management system fused with game theory, characterized in that, The system includes: an initialization module configured to obtain coalition institution basic configuration data and historical behavior audit data of the medical institutions, and construct a privacy mechanism capability directory and calculate an initial trust state vector based on the data; The path modeling module is configured to receive privacy computing task request data, combine a privacy mechanism capability directory, and parse the task to generate a multi-channel privacy path candidate set. The multi-channel privacy path is a complete execution path formed by matching a feasible privacy computing channel to each subtask after the privacy computing task is decomposed into multiple subtasks. The multi-channel privacy path represents a specific technical implementation from the beginning of the task to the end of the task. The privacy computing channel includes a local differential privacy channel, a cross-institution homomorphic encryption channel, a cross-institution secure multi-party computing channel, or a trusted execution environment channel. The game solving module is configured to construct and solve a heterogeneous privacy path selection game based on the multi-channel privacy path candidate set and an initial trust state vector, and derive a task privacy execution path plan. The execution collection module is configured to schedule medical institutions to perform joint privacy computing and collect actual execution behavior index data according to the task privacy execution path plan. The trust updating module is configured to update the trust state to obtain a coalition trust state vector according to the actual execution behavior index data, and generate a privacy mode upgrade strategy data based on the coalition trust state vector.

Images