Intelligent federal learning cross-component privacy query method, related device and storage medium

Abstract

The embodiment of the invention relates to the field of big data, and provides an intelligent federal learning cross-component privacy query method, a related device and a storage medium. Generating a plurality of subtasks and corresponding privacy budget and sensitivity; on the basis of the data source types of the sub-tasks and the dynamic weights of the federated components, distributing the sub-tasks to the federated components; receiving a noise adding result of each federated component; and aggregating the noise adding results returned by the federated components to obtain an aggregation result, and compensating and denoising the aggregation result to obtain a query result. According to the embodiment of the invention, when the query request is executed, the query request is split into a plurality of sub-tasks according to the data source, and the privacy budget and sensitivity are given, so that the federated component executing each sub-task performs noise adding processing on the intermediate result, and the privacy of the intermediate result is ensured; the subtasks are distributed according to the data source type, it can be guaranteed that the data source is not leaked, the subtasks are distributed based on the federated component dynamic weight, and the end-to-end execution speed can be guaranteed.

Description

Technical Field

[0001] This application relates to the field of big data, and more specifically to a method, related apparatus, and storage medium for cross-component privacy query in intelligent federated learning. Background Technology

[0002] In the realm of cross-component privacy queries within federated learning, current query methods typically involve directly sending the complete query statement to each participating party. Each party then executes the query locally and returns its results to the central node for aggregation. This approach exposes the raw data and unprotected intermediate results to a high risk of privacy breaches during transmission. Furthermore, current methods ignore the heterogeneity of participating parties when sending the query statement, leading to lengthy query processes for parties with limited computing resources, significantly increasing end-to-end latency and reducing processing efficiency. Summary of the Invention

[0003] This application provides a method, apparatus, and storage medium for cross-component privacy query in intelligent federated learning, aiming to solve the problems of privacy leakage and low processing efficiency in existing query methods.

[0004] In a first aspect, embodiments of this application provide a method for cross-component privacy queries in intelligent federated learning, the method comprising: Get the query request; Multiple subtasks are generated based on the data source corresponding to the query request; Generate a privacy budget and sensitivity for each subtask; Based on the type of data source corresponding to each subtask and the dynamic weight of each federation component, each subtask is assigned to a federation component for execution; wherein, the type of data source is exclusive data or shared data, the exclusive data indicates that only a single federation component can access the data source, the shared data indicates that multiple federation components can access the data source, and the dynamic weight represents the real-time query capability of the federation component. Receive the noise-adding results of each federated component; wherein, the noise-adding result of each federated component is obtained by adding noise based on the intermediate results of that federated component and the privacy budget and sensitivity of the subtask corresponding to that federated component; The noisy results returned by each federated component are aggregated to obtain an aggregated result. The aggregated result is then compensated and denoised to obtain the query result.

[0005] In one implementation, the step of generating multiple sub-tasks based on the data source corresponding to the query request includes: A query syntax tree is constructed based on the query request. The query syntax tree includes a root node, multiple first-level child nodes, and leaf nodes corresponding to each first-level child node. The root node is used to store the operation type of the query request. The multiple first-level child nodes include at least a first-level child node for storing the data source corresponding to the query request, a first-level child node for storing the query conditions corresponding to the query request, and a first-level child node for storing the aggregation conditions corresponding to the query request. The leaf nodes corresponding to each first-level child node are used to store the atomic elements of their respective first-level child nodes. Traverse the first-level child nodes and leaf nodes corresponding to the data sources in the query syntax tree to determine all data sources included in the query request, as well as the federated components to which each data source belongs; The query request is divided into multiple subtasks based on each of the data sources, and each subtask corresponds to a data source.

[0006] In one implementation, generating a privacy budget and sensitivity for each subtask includes: The privacy budget for each subtask is determined based on a preset global privacy policy or the parameters specified in the query request. The difference between the maximum and minimum values ​​of each field in the data source corresponding to any subtask is used as the sensitivity of that subtask.

[0007] In one implementation, the step of assigning each subtask to a federation component for execution based on the type of data source corresponding to each subtask and the dynamic weights of each federation component includes: Assign subtasks with a data source type of exclusive data to the first target federation component, which is a federation component that has a unique data source corresponding to the subtask. Subtasks of shared data types are assigned to a second target federation component, which is the federation component with the highest dynamic weight among all federation components that have the data source corresponding to the subtask; wherein, the dynamic weight is determined based on the current CPU utilization, memory usage, and network latency of the federation component.

[0008] In one implementation, assigning a subtask with a data source type of dedicated data to a first target federation component includes: A subtask queue is constructed for the first target federated component. When the current concurrency of the first target federated component exceeds the preset maximum concurrency, the subtasks are stored in the subtask queue. When the current concurrency of the first target federated component is less than the maximum concurrency, the subtasks are allocated sequentially based on the subtask queue.

[0009] In one implementation, after assigning subtasks of shared data types to a second target federated component, the method further includes: The dynamic weights of each federated component with the data source corresponding to the subtask are monitored in real time. When the difference between the dynamic weight of any other federated component and the dynamic weight of the second target federated component exceeds a preset value, the subtask is migrated to the second target federated component.

[0010] Secondly, embodiments of this application provide an intelligent federated learning cross-component privacy query device, which has the function of implementing the intelligent federated learning cross-component privacy query method corresponding to the first aspect described above. The function can be implemented by hardware or by hardware executing corresponding software. The hardware or software includes one or more modules corresponding to the above function, and the modules can be software and / or hardware.

[0011] In one implementation, the intelligent federated learning cross-component privacy query apparatus includes: The input / output module is configured to retrieve query requests; The processing module is configured to generate multiple subtasks for the data source corresponding to the query request; Generate a privacy budget and sensitivity for each subtask; Based on the type of data source corresponding to each subtask and the dynamic weight of each federation component, each subtask is assigned to each federation component for execution; wherein, the type of data source is exclusive data or shared data, the exclusive data indicates that only a single federation component has the data source, the shared data indicates that multiple federation components have the data source, and the dynamic weight represents the real-time query capability of the federation component. Receive the noise-adding results of each federated component; wherein, the noise-adding result of each federated component is obtained by adding noise based on the intermediate results of that federated component and the privacy budget and sensitivity of the subtask corresponding to that federated component; The noisy results returned by each federated component are aggregated to obtain an aggregated result. The aggregated result is then compensated and denoised to obtain the query result.

[0012] Thirdly, embodiments of this application provide a computer-readable storage medium including instructions that, when executed on a computer, cause the computer to perform the intelligent federated learning cross-component privacy query method as described in the first aspect.

[0013] Fourthly, embodiments of this application provide a computing 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 intelligent federated learning cross-component privacy query method described in the first aspect.

[0014] Fifthly, embodiments of this application provide a computer program product containing instructions that, when run on a computer, cause the computer to execute the intelligent federated learning cross-component privacy query method provided in the first aspect.

[0015] Compared to existing technologies, in this embodiment, when executing a query request, the query request is split into multiple sub-tasks according to the data source. Each sub-task is assigned a corresponding privacy budget and sensitivity, so that the federated components executing each sub-task can add noise to the intermediate results, thereby ensuring the privacy of the intermediate results. When distributing sub-tasks, they are distributed according to the type of data source, which can ensure that the data source is not leaked. Moreover, when distributing sub-tasks, dynamic weight allocation based on each federated component can ensure end-to-end execution speed and improve query efficiency. Attached Figure Description

[0016] The objectives, features, and advantages of the embodiments of this application will become readily understood by referring to the accompanying drawings and the detailed description of the embodiments. Wherein: Figure 1 This is a flowchart illustrating a cross-component privacy query method for intelligent federated learning according to an embodiment of this application. Figure 2 This is a schematic diagram of the structure of the intelligent federated learning cross-component privacy query device according to an embodiment of this application; Figure 3 This is a schematic diagram of the structure of a computing device according to an embodiment of this application; Figure 4 This is a schematic diagram of a server structure in one embodiment of this application.

[0017] In the accompanying drawings, the same or corresponding reference numerals indicate the same or corresponding parts. Detailed Implementation

[0018] The terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects (e.g., the first target federated component and the second target federated component are represented as different federated components, and so on), and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments described herein can be implemented in a sequence other than that illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or modules is not necessarily limited to those steps or modules explicitly listed, but may include other steps or modules not explicitly listed or inherent to these processes, methods, products, or devices. The division of modules appearing in the embodiments of this application is merely a logical division; in actual applications, there may be other division methods. For example, multiple modules may be combined into or integrated into another system, or some features may be ignored or not performed. Furthermore, the displayed or discussed mutual couplings, direct couplings, or communication connections may be through interfaces, indirect couplings between modules, or electrical or other similar forms of communication connections, none of which are limited in the embodiments of this application. Moreover, the modules or sub-modules described as separate components may or may not be physically separate, may or may not be physical modules, or may be distributed across multiple circuit modules. Some or all of these modules can be selected according to actual needs to achieve the purpose of the embodiments of this application.

[0019] This application also provides a method, related apparatus and storage medium for cross-component privacy query in intelligent federated learning, which can be applied to federated learning systems in cross-component scenarios. The federated learning system may include multiple federated components with local data sources. Each federated component follows a distributed machine learning paradigm. Each federated component is independent of the others and works together to train a machine learning model or complete a data analysis task or a data query task.

[0020] The solutions provided in this application involve technologies such as Artificial Intelligence (AI) and Machine Learning (ML), and are specifically illustrated through the following embodiments: AI, or Artificial Intelligence, refers to the theories, methods, technologies, and application systems that utilize digital computers or machines controlled by digital computers to simulate, extend, and expand human intelligence, perceive the environment, acquire knowledge, and use that knowledge to achieve optimal results. In other words, Artificial Intelligence is a comprehensive technology within computer science that attempts to understand the essence of intelligence and produce a new kind of intelligent machine capable of reacting in a manner similar to human intelligence. Artificial Intelligence studies the design principles and implementation methods of various intelligent machines, enabling them to possess the functions of perception, reasoning, and decision-making.

[0021] AI technology is a comprehensive discipline encompassing a wide range of fields, including both hardware and software technologies. Fundamental AI technologies generally include sensors, dedicated AI chips, cloud computing, distributed storage, big data processing, operating / interactive systems, and mechatronics. AI software technologies primarily include computer vision, speech processing, natural language processing, and machine learning / deep learning.

[0022] In existing technologies, within the field of cross-component privacy queries in federated learning, current query methods typically involve directly sending the complete query statement to each participating party. Each participating party then executes the query locally and returns its results to the central node for aggregation. This approach exposes the raw data and unprotected intermediate results to a high risk of privacy leakage during transmission. Furthermore, current query methods ignore the heterogeneity of participating parties when sending the query statement, leading to lengthy query processes for parties with limited computing resources, significantly increasing end-to-end latency and reducing processing efficiency.

[0023] Compared to existing technologies, in this embodiment, when executing a query request, the query request is split into multiple sub-tasks according to the data source. Each sub-task is assigned a corresponding privacy budget and sensitivity, so that the federated components executing each sub-task can add noise to the intermediate results, thereby ensuring the privacy of the intermediate results. When distributing sub-tasks, they are distributed according to the type of data source, which can ensure that the data source is not leaked. Moreover, when distributing sub-tasks, dynamic weight allocation based on each federated component can ensure end-to-end execution speed and improve query efficiency.

[0024] The computing devices involved in the embodiments of this application may be servers and / or terminal devices.

[0025] The server involved in the embodiments of this application can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms.

[0026] The terminal devices involved in the embodiments of this application can be devices that provide voice and / or data connectivity to users, handheld devices with wireless connectivity, or other processing devices connected to a wireless modem. Examples include mobile phones (or "cellular" phones) and computers with mobile terminals, such as portable, pocket-sized, handheld, computer-embedded, or vehicle-mounted mobile devices that exchange voice and / or data with a wireless access network. Examples include Personal Communication Service (PCS) phones, cordless phones, Session Initiation Protocol (SIP) phones, Wireless Local Loop (WLL) stations, Personal Digital Assistants (PDAs), and other devices.

[0027] Reference Figure 1 , Figure 1 This is a flowchart illustrating a cross-component privacy query method for intelligent federated learning, provided in an embodiment of this application. This method can be executed by an intelligent federated learning cross-component privacy query device and can be applied to cross-component query scenarios in federated learning. The method includes steps S100-S600: S100: Get query request.

[0028] In this embodiment of the application, user query requests can be received based on the input interface of the federated learning system. The input interface can be a standard Web service interface, such as a RESTful API. User query requests can be sent based on the HTTP / RPC protocol, and the query requests can be SQL-formatted query statements.

[0029] In this embodiment of the application, the query request includes information such as user ID, data source, operation type, table name, and field name.

[0030] In the embodiments of this application, the operation type of the query request may include data retrieval (SELECT), data operation (INSERT / UPDATE / DELETE), structure definition (CREATETABLE / INDEX), aggregation operation (SUM / AVG / COUNT), multi-table join (JOIN), etc.

[0031] S200: Generate multiple sub-tasks based on the data source corresponding to the query request.

[0032] In this embodiment of the application, subtasks can be generated based on the following steps S210-S230: S210: Construct a query syntax tree based on the query request. The query syntax tree includes a root node, multiple first-level child nodes, and leaf nodes corresponding to each first-level child node. The root node is used to store the operation type of the query request. The multiple first-level child nodes include at least a first-level child node for storing the data source corresponding to the query request, a first-level child node for storing the query conditions corresponding to the query request, and a first-level child node for storing the aggregation conditions corresponding to the query request. The leaf nodes corresponding to each first-level child node are used to store the atomic elements of their respective first-level child nodes.

[0033] In this embodiment, after obtaining the user's query request, the query request can be parsed based on an SQL parser. The SQL parser has a predefined list of keywords and rules, such as SELECT, FROM, WHERE, AVG, >, identifiers, numbers, and strings. Based on the SQL parser, each token in the query request is identified sequentially, thereby identifying each unit.

[0034] In this embodiment, a Token represents the smallest unit the parser uses to break down a query request when parsing it. For example, the query request can first be broken down into individual Tokens based on the SQL parser; then, each Token can be identified based on the SQL syntax rules to construct a syntax query tree.

[0035] In this embodiment, a query request corresponds to an operation type. Therefore, when constructing the query syntax tree, the root node of the query syntax tree is the operation type of the query request. Each first-level child node includes at least three nodes, which are used to store the data source, query conditions, and aggregation conditions in the query request, respectively. Leaf nodes under each first-level child node store the atomic elements of the corresponding first-level child node. The atomic elements in the leaf nodes are the basic constants or keywords of the query statement in their corresponding first-level child nodes, such as column names, table names, operators, function names, and other indivisible independent symbols.

[0036] For example, in this embodiment of the application, for the query request: SELECT AVG(salary) FROM table1, table2, table3 WHERE age>30, this query request means to find all records in tables1, 2, and 3 where the age is greater than 30, and calculate the average value of the salary field in these records.

[0037] The operation type for the root node is SELECT; First-level child nodes include: DataSources: table1, table2, table3 Conditions (query criteria): age > 30 Aggregations (aggregation conditions): AVG (salary) The leaf nodes of the first-level child node DataSources can include: table1@FedA, table2@FedB, table3@FedC, FedD, and FedE. These represent that the federation component to which data source table1 belongs is FedA, the federation component to which data source table2 belongs is FedB, and the federation component to which data source table3 belongs is FedC, FedD, and FedE. Here, table1, table2, and table3 are the identifiers of the table names corresponding to each data source, and FedA, FedB, FedC, FedD, and FedE are the identifiers of the federation components.

[0038] The leaf nodes of the first-level child node Conditions can include: column reference age, numeric literal 30.

[0039] The leaf nodes of the first-level child nodes Aggregations can include: column references salary.

[0040] That is, the atomic elements contained in the leaf node can be: column references (COLUMN_REF), such as age, salary; literals (LITERAL), such as 30; operators (OPERATOR), such as >; function calls (FUNCTION_CALL), such as AVG; table / federation component identifiers, such as table1, table2, table3, FedA, FedB, FedC, FedD, FedE.

[0041] S220: Traverse the first-level child nodes and leaf nodes corresponding to the data sources in the query syntax tree to determine all data sources included in the query request, as well as the federated components to which each data source belongs; In this embodiment of the application, after the query syntax tree is constructed, the first-level child nodes DataSources and their leaf nodes in the query syntax tree can be traversed to determine all data sources and federated components included in the query request.

[0042] Taking the above query request as an example, it can be seen that the data sources included in the query request are table1, table2, and table3. The federated component of table1 is FedA, the federated component of table2 is FedB, and the federated components of table3 are FedC, FedD, and FedE. Table3 is shared data, and the federated components FedC, FedD, and FedE all have this data source.

[0043] S230: Based on each of the data sources, the query request is split into multiple sub-tasks, and each sub-task corresponds to a data source.

[0044] In step S220, it is determined that the data sources included in the query request are table1, table2, and table3. Therefore, in this embodiment of the application, the query request can be divided into three sub-tasks, and the data sources corresponding to the three sub-tasks are table1, table2, and table3, respectively.

[0045] S300: Generates privacy budget and sensitivity for each subtask.

[0046] In this embodiment of the application, a privacy budget and sensitivity can be generated for each subtask based on the following steps S310-S320: S310: Determine the privacy budget for each subtask based on the preset global privacy policy or the parameters specified in the query request.

[0047] S320: The difference between the maximum and minimum values ​​of each field in the data source corresponding to any subtask is used as the sensitivity of that subtask.

[0048] In the embodiments of this application, for aggregation calculation subtasks involving sensitive fields, such as SUM, AVG, and COUNT, after splitting the subtasks, differential privacy parameters are added to each subtask: privacy budget ε and sensitivity Δf.

[0049] In this embodiment, the privacy budget ε is a non-negative real number representing the privacy budget that is allowed to be consumed when a subtask is queried. The privacy budget represents the strength of privacy protection. The smaller the value, the greater the noise added and the stronger the privacy protection.

[0050] In this embodiment, the privacy budget for each subtask can be determined based on the budget cap in the global budget strategy and the weights of each subtask. For example, for each query request, a budget cap is pre-set, and the privacy budget for each subtask is obtained from the budget cap based on the weight of that subtask.

[0051] In this embodiment of the application, an average allocation strategy can be adopted, in which the weights of each subtask are the same, and the privacy budget of each subtask is obtained by the average allocation of the budget upper limit.

[0052] In this embodiment, the weight of each subtask can be determined by the sensitivity of the data source corresponding to that subtask. For example, a smaller privacy budget can be assigned to frequently sensitive data sources such as medical records and salaries, while a larger privacy budget can be assigned to generally sensitive data sources such as shopping records. The sum of the privacy budgets of all subtasks is the upper limit of the budget.

[0053] In this embodiment of the application, sensitivity Δf represents the maximum possible range of variation of a data field in a data source.

[0054] For example, in this embodiment, Δf is the difference between the maximum and minimum values ​​of all fields in the specific data queried by the subtask. For instance, when querying age, it is the difference between the maximum and minimum values ​​of all age values ​​corresponding to the subtask; when querying salary, it is the difference between the maximum and minimum values ​​of all salary values ​​corresponding to the subtask.

[0055] For example, for the query request: SELECT AVG(salary) FROM table1, table2, table3 WHERE age>30, the three subtasks correspond to three data sources: table1, table2, and table3. The Δf of the subtask corresponding to table1 is the difference between the maximum and minimum salary in table1, the Δf of the subtask corresponding to table2 is the difference between the maximum and minimum salary in table2, and the Δf of the subtask corresponding to table3 is the difference between the maximum and minimum salary in table3.

[0056] S400: Based on the type of data source corresponding to each subtask and the dynamic weight of each federation component, each subtask is assigned to a federation component for execution; wherein, the type of data source is exclusive data or shared data, exclusive data indicates that only a single federation component can access the data source, shared data indicates that multiple federation components can access the data source, and the dynamic weight represents the real-time query capability of the federation component.

[0057] In this embodiment of the application, the data type of each data source can be determined based on the following method: Method 1: Static registration configuration In this embodiment, the federated learning system can maintain a global mapping table between each data source and each federated component. When each federated component joins the federated learning system, it holds the data source information with the federated learning system registrar. For example, FedA can access Table1, FedB can access Table2, FedC can access Table3, and FedD can access Table3. When splitting subtasks, after traversing each data source in the first-level child node, the federated component that can access the data source can be determined based on the global mapping table between the data source and the federated component.

[0058] If any data source in the global mapping table corresponds to only one federation component, it means that the data source is dedicated data; if any data source corresponds to multiple federation components, it means that the data source is shared data.

[0059] Method 2: Data Source Identifier Resolution In this embodiment, the federated learning system can define naming rules for query requests, such as `table_name@engine_id`. This means that when a user constructs a query request, they must expose the requested data source and its corresponding federated component. Furthermore, when parsing the query request, the SQL parser can determine the federated component corresponding to the data source. If there is only one federated component corresponding to the data source, it represents exclusive data; if there are multiple components, it represents shared data.

[0060] In this embodiment of the application, the dynamic weight of the federated component can be determined based on the current CPU utilization, memory usage, and network latency.

[0061] In this embodiment, the dynamic weight calculation formula for each federated component is as follows: Weightᵢ = α(1 / CPUᵢ) + β(Mem_free,i / Mem_total,i) + γ(1 / NetLatencyᵢ) Where Weightᵢ represents the dynamic weight of the i-th federated component, CPUᵢ represents the current CPU utilization of the i-th federated component, Mem_free,i represents the current free memory of the i-th federated component, Mem_total,i represents the total memory of the i-th federated component, NetLatencyᵢ represents the current network latency of the i-th federated component, and α, β, γ represent the weighting coefficients of CPU utilization, memory utilization, and network latency, and α+β+γ=1.

[0062] After determining the types of each data source and the current dynamic weights of each federation component, the federation component that executes each subtask can be determined based on the following method: Assign subtasks with a data source type of exclusive data to the first target federation component, which is a federation component that has a unique data source corresponding to the subtask. Subtasks of shared data types are assigned to a second target federated component, which is the federated component with the largest dynamic weight among all federated components that have the data source corresponding to the subtask; wherein, the dynamic weight is based on the federated component.

[0063] In this embodiment of the application, the subtasks corresponding to the data source with exclusive data must be sent to the corresponding federated component for execution in order to ensure that the data source exclusively owned by the federated component is not leaked.

[0064] For data sources that share data, since they correspond to multiple federated components, the federated component with the highest dynamic weight among the multiple federated components corresponding to the data source is selected to execute the subtask, thereby ensuring end-to-end execution speed and improving query efficiency.

[0065] In this embodiment, after determining the privacy budget ε and sensitivity Δf of each subtask, as well as the data source type and dynamic weights of the federation components, each subtask and the federation component executing each subtask can be determined. For each subtask, a subtask description file can be constructed as follows: Subtask 1 description file: target_engine: FedA sql_fragment: SELECT COUNT(*) FROM table1 WHERE age>30 privacy_params: {ε: **, Δf: **} Subtask 2 description file: target_engine: FedB sql_fragment: SELECT COUNT(*) FROM table2 WHERE age>30 privacy_params: {ε: **, Δf: **} Subtask 3 description file: target_engine: FedC sql_fragment: SELECT COUNT(*) FROM table3 WHERE age>30 privacy_params: {ε: **, Δf: **} In this context, target_engine represents the federated component engine that executes the subtask, sql_fragment represents the specific task to be executed, privacy_params represents the basis for adding noise, and "ε:**" and "Δf:**" are determined based on the specific situation. In subtask 3, target_engine: FedC represents FedC. Among FedC, FedD, and FedE, FedC has the largest dynamic weight, so subtask 3 is executed by FedC.

[0066] S500: Receives the noise-adding results of each federated component; wherein, the noise-adding result of each federated component is obtained by adding noise based on the intermediate results of the federated component and the privacy budget and sensitivity of the subtask corresponding to the federated component.

[0067] In this embodiment of the application, after each subtask configuration file is sent to its corresponding federation component, each federation component can execute the corresponding subtask.

[0068] In the embodiments of this application, intermediate results refer to the output data generated by each participant (federated component) after executing subtasks locally during the federated learning query processing. This data has undergone preliminary processing but has not yet been globally aggregated.

[0069] Suppose that any federated component obtains an intermediate result f(x) after executing its corresponding subtask. If the intermediate result is returned directly, privacy may be easily leaked during transmission. Therefore, noise needs to be added based on the privacy budget ε and sensitivity Δf in the subtask to prevent privacy leakage of the intermediate result during transmission.

[0070] In this embodiment, noise can be added based on the privacy budget ε and sensitivity Δf. Specifically, noise can be added based on the following formula: S∈Lap(0, Δf / ε) Where S represents the added noise, and L is a Laplace distribution, indicating that the added noise follows a Laplace distribution constructed based on the privacy budget ε and the sensitivity Δf.

[0071] Once the noise is obtained, it can be added to the intermediate results to obtain the noisy result, as shown below: Ri = fi(x) + Lap(0, Δf / ε) Where Ri represents the noise addition result of the i-th federated component, fi(x) represents the intermediate result of the i-th federated component, and Lap(0, Δf / ε) represents the noise added by the i-th federated component.

[0072] S600: Aggregate the noisy results returned by each federated component to obtain an aggregated result, and compensate and denoise the aggregated result to obtain the query result.

[0073] In this embodiment, when each federated component returns the noise-adding result to the master node, it can also perform a hash operation on the noise-adding result to obtain a hash value. Then, it sends the noise-adding result and its corresponding hash value to the master node. After receiving the noise-adding result, the master node hashes the noise-adding result again and compares the hash value obtained from the second hash with the received hash value. If they match, it means that the noise-adding result has not been tampered with during transmission. If they do not match, it means that the noise-adding result has been tampered with, thereby further ensuring the accuracy of the query results.

[0074] In this embodiment, a timestamp can be added to the noise-added result, and then a hash operation can be performed on it to obtain a hash value. This hash value and the noise-added result are then returned to the master node. In this way, even if an attacker intercepts a valid Ri and its corresponding hash value, they cannot resend it at another point in time and pass the verification.

[0075] In this embodiment, the long-term expected value of Laplace noise is 0, meaning that the average value of the noise added by the federated components corresponding to each subtask will tend to 0. Therefore, after receiving the noise addition results returned by each federated component, the noise addition deviation of each federated component is determined based on the operation type in the query request, and then the noise addition deviation is removed to obtain the final query result.

[0076] For query requests with operation type SUM The results are aggregated based on the following formula:

[0077] in, The aggregated result representing the noise addition results of each federated component. This represents the noise-added result returned by the i-th federated component, where k is the number of federated components involved in the query.

[0078] In the SUM query, the long-term average expected value of the Laplace noise of each federated component is 0. While the expected value of the sum of the Laplace noise of the k federated components is 0, its actual value is usually not 0. Therefore, it can be based on... Remove the expected bias.

[0079] Specifically, the query results after removing bias can be calculated based on the following formula:

[0080] in, This represents the final query result. The aggregated result representing the noise addition results of each federated component. This represents noise bias.

[0081] For query requests with operation type AVG The average noise addition result of each federated component is calculated based on the following formula:

[0082] in, This represents the average noise addition result for each federated component. This represents the noise-added result returned by the i-th federated component, where k is the number of federated components involved in the query.

[0083] The query results after removing bias are calculated based on the following formula:

[0084] in, This represents the average noise addition result for each federated component. The standard deviation of the average noise of each federated component This represents the final query result.

[0085] For query requests with operation type COUNT In this embodiment of the application, the COUNT query request can be regarded as a special type of SUM query request. Unlike the SUM query request, in the COUNT query, the intermediate result of each federated component is a specific row number. Whether the intermediate result of each federated component exists or not will cause the biggest change to the query result. When the query request is COUNT, the sensitivity Δf of each subtask can be set to 1.

[0086] The results are aggregated based on the following formula:

[0087] in, The aggregated result representing the noise addition results of each federated component. This represents the noise-added result returned by the i-th federated component, where k is the number of federated components involved in the query.

[0088] In the COUNT query, the long-term average expected value of the Laplace noise of each federated component is 0. While the expected value of the sum of the Laplace noise of the k federated components is 0, its actual value is usually not 0. Therefore, it can be based on... Remove the expected bias, where Δf=1.

[0089] Specifically, the query results after removing bias can be calculated based on the following formula:

[0090] in, This represents the final query result. The aggregated result representing the noise addition results of each federated component. This represents the noise addition bias, Δf=1.

[0091] Denoising each noise-added result individually requires subtracting Δf / ε from each intermediate result. However, the local noise of each federated component is a random variable, with values ​​that can be large, small, or even negative. Therefore, forcibly subtracting a fixed value Δf / ε from each intermediate result is equivalent to assuming that the noise of each federated component is exactly Δf / ε, leading to overcorrection, introducing larger errors, and disrupting the noise distribution characteristics. Furthermore, if denoising is performed separately based on each noise-added result, the intermediate results for each federated component are obtained after denoising, thus failing to protect the privacy of the data from each federated component. The embodiments of this application, by first aggregating the noise-added results of each federated component and then performing comprehensive denoising, not only avoid over-denoising but also protect the privacy of the data sources of each federated component. In this embodiment, when executing a query request, the query request is split into multiple subtasks according to the data source. Each subtask is assigned a corresponding privacy budget and sensitivity, so that the federated components executing each subtask can add noise to the intermediate results, thereby ensuring the privacy of the intermediate results. When distributing subtasks, they are distributed according to the type of data source, which can ensure that the data source is not leaked. Moreover, when distributing subtasks, dynamic weight allocation based on each federated component can ensure end-to-end execution speed and improve query efficiency.

[0092] In this embodiment of the application, assigning a subtask with a data source type of dedicated data to the first target federated component includes: A subtask queue is constructed for the first target federated component. When the current concurrency of the first target federated component exceeds the preset maximum concurrency, the subtasks are stored in the subtask queue and await allocation. When the current concurrency of the first target federated component is less than the maximum concurrency, each subtask is sequentially allocated to the corresponding federated component based on the subtask queue.

[0093] In this embodiment of the application, since the data source of the exclusive data corresponds to only one federation component, the federation component may have many sub-tasks to perform. If sub-tasks are continuously assigned to the federation component, it may cause the federation component to be under high load, resulting in slow query.

[0094] Therefore, in this embodiment of the application, for a federated component with exclusive data, a subtask queue can be built for it and a concurrency number can be set. Whenever a subtask needs to be assigned to the federated component, the subtask can be cached in the subtask queue and assigned to the federated component in sequence according to the preset concurrency number, thereby avoiding the federated component being under high load for a long time.

[0095] In this embodiment of the application, after assigning subtasks of shared data types to the second target federated component, the method further includes: The dynamic weights of each federated component with the data source corresponding to the subtask are monitored in real time. When the difference between the dynamic weight of any other federated component and the dynamic weight of the second target federated component exceeds a preset value, the subtask is migrated to the second target federated component.

[0096] Taking the above query request: SELECT AVG(salary) FROM table1, table2, table3 WHERE age>30 as an example, subtask 3 is assigned to TableC. When FedC executes subtask 3, the dynamic weights of FedC, FedD, and FedE are monitored in real time. When the difference between the dynamic weight of FedD or FedE and the dynamic weight of FedC exceeds the preset value, it means that FedD or FedE is executing the subtask faster under its current load. Therefore, subtask 3 can be migrated to FedD or FedE at this time.

[0097] In this embodiment of the application, after aggregating the noisy results returned by each federated component to obtain an aggregated result, and then compensating and denoising the aggregated result to obtain the query result, the obtained query result can also be formatted according to the query type of the query request, as follows: For example, if the query request type is a numeric operation (such as SUM, AVG, COUNT), the query result is a directly usable numeric result. In this case, the query result does not need to be converted and can be directly output. For example, the query result can be input into a standard response format (such as JSON) and returned.

[0098] If the query request type is a non-numeric operation (such as INSERT, UPDATE, DELETE), for example, an UPDATE query request executed on the engines of three federated components, affecting 10, 15, and 5 rows of data respectively, but the query result obtained by such a query request is a confirmation message of successful operation, then it is necessary to convert the query result into the "number of rows affected" after each federated component executes the UPDATE query request, such as 10, 15, and 5, so that users can clearly see how many rows of data the UPDATE query request affected.

[0099] If the query request type is a multi-table join operation, the query result will be a data set that has been joined and denoised, such as a virtual table. In this case, the virtual table can be output in a standard data exchange format, such as JSON array format or CSV string format.

[0100] In one of the application embodiments, the intelligent federated learning cross-component privacy query method further includes: recording full-link logs in real time based on an independent audit channel, and auditing and verifying the compliance of the query process based on the full-link logs.

[0101] For example, when each federated component adds noise to its intermediate results, it can record whether noise has been added based on the privacy_params field of the subtask log. During auditing, the privacy_params field is checked, and if ε≥0.1, it means that noise has been added.

[0102] For example, when verifying whether each federated component has data access rights, the digital certificate is recorded based on the engine_cert field of the distribution log. During auditing, the validity of the engine_cert field is verified, and if it is valid, it means that the component has the necessary permissions.

[0103] For example, when the central node receives the noise-enhanced results returned by each federated component and compares the hash values, it records the original hash value based on the subtask_hash field of the transmission log. During auditing, the hash value is recalculated and compared with the original hash value recorded in the subtask_hash field. If they match, the verification is successful.

[0104] For example, the timestamp sequence of the end-to-end log is used to record timestamps. When auditing whether the timestamp chain is continuous and unbroken, the timestamp sequence of the end-to-end log can be used to determine whether the timestamps are continuous and unbroken.

[0105] In addition, in this embodiment of the application, the log can be automatically signed after being written to Kafka: Sign=ECDSA(HASH_log), which can serve as a means to prevent tampering.

[0106] In this embodiment, when executing a query request, the query request is split into multiple subtasks according to the data source. Each subtask is assigned a corresponding privacy budget and sensitivity, so that the federated components executing each subtask can add noise to the intermediate results, thereby ensuring the privacy of the intermediate results. When distributing subtasks, they are distributed according to the type of data source, which can ensure that the data source is not leaked. Moreover, when distributing subtasks, dynamic weight allocation based on each federated component can ensure end-to-end execution speed and improve query efficiency.

[0107] The above describes a method for cross-component privacy query in intelligent federated learning according to an embodiment of this application. The following describes the intelligent federated learning cross-component privacy query device (e.g., a server) that performs the above method.

[0108] See Figure 2 ,like Figure 2 The diagram illustrates the structure of a cross-component privacy query device for intelligent federated learning, which can be applied to the field of cross-component privacy queries in intelligent federated learning. The intelligent federated learning cross-component privacy query device in this embodiment can achieve the functions described above. Figure 1 The steps of the intelligent federated learning cross-component privacy query method executed in the corresponding embodiments are described above. The functions implemented by the intelligent federated learning cross-component privacy query device can be implemented in hardware or by hardware executing corresponding software. The hardware or software includes one or more modules corresponding to the above functions, and the modules can be software and / or hardware. The intelligent federated learning cross-component privacy query device may include an input / output module 601 and a processing module 602. The functional implementation of the processing module 602 and the input / output module 601 can be found in [reference missing]. Figure 1 The operations performed in the corresponding embodiments will not be described in detail here. For example, the processing module 602 can be used to control the sending, receiving, and acquiring operations of the input / output module 601. The input / output module 601 is configured to obtain query requests; The processing module 602 is configured to: Multiple subtasks are generated based on the data source corresponding to the query request; Generate a privacy budget and sensitivity for each subtask; Based on the type of data source corresponding to each subtask and the dynamic weight of each federation component, each subtask is assigned to a federation component for execution; wherein, the type of data source is exclusive data or shared data, the exclusive data indicates that only a single federation component can access the data source, the shared data indicates that multiple federation components can access the data source, and the dynamic weight represents the real-time query capability of the federation component. Receive the noise-adding results of each federated component; wherein, the noise-adding result of each federated component is obtained by adding noise based on the intermediate results of that federated component and the privacy budget and sensitivity of the subtask corresponding to that federated component; The noisy results returned by each federated component are aggregated to obtain an aggregated result. The aggregated result is then compensated and denoised to obtain the query result.

[0109] In some implementations, the processing module 602 is configured to: construct a query syntax tree based on the query request, the query syntax tree including a root node, multiple first-level child nodes, and leaf nodes corresponding to each first-level child node; wherein, the root node is used to store the operation type of the query request, the multiple first-level child nodes include at least a first-level child node for storing the data source corresponding to the query request, a first-level child node for storing the query conditions corresponding to the query request, and a first-level child node for storing the aggregation conditions corresponding to the query request, and the leaf nodes corresponding to each first-level child node are used to store the atomic elements of their corresponding first-level child node; Traverse the first-level child nodes and leaf nodes corresponding to the data sources in the query syntax tree to determine all data sources included in the query request, as well as the federated components to which each data source belongs; The query request is divided into multiple subtasks based on each of the data sources, and each subtask corresponds to a data source.

[0110] In some implementations, the processing module 602 is configured to: determine the privacy budget corresponding to each subtask based on a preset global privacy policy or parameters specified in the query request; The difference between the maximum and minimum values ​​of each field in the data source corresponding to any subtask is used as the sensitivity of that subtask.

[0111] In some implementations, the processing module 602 is configured to: assign a subtask with a data source type of exclusive data to a first target federation component, wherein the first target federation component is a federation component that has exclusive data source corresponding to the subtask; Subtasks of shared data types are assigned to a second target federation component, which is the federation component with the highest dynamic weight among all federation components that have the data source corresponding to the subtask; wherein, the dynamic weight is determined based on the current CPU utilization, memory usage, and network latency of the federation component.

[0112] In some implementations, the processing module 602 is configured to: construct a subtask queue for the first target federated component; when the current task concurrency of the first target federated component exceeds a preset maximum concurrency, store the subtasks in the subtask queue; when the current task concurrency of the first target federated component is less than the maximum concurrency, sequentially allocate each subtask based on the subtask queue. In this embodiment, when executing a query request, the processing module 602 splits the query request into multiple subtasks according to the data source, assigning each subtask a corresponding privacy budget and sensitivity, so that the federated components executing each subtask can add noise to the intermediate results, thereby ensuring the privacy of the intermediate results; when distributing subtasks, they are distributed according to the type of data source, which can ensure that the data source is not leaked; and when distributing subtasks, they are also allocated based on the dynamic weight allocation of each federated component, which can ensure end-to-end execution speed and improve query efficiency.

[0113] The intelligent federated learning cross-component privacy query device 60 in this application embodiment has been described above from the perspective of modular functional entities. The intelligent federated learning cross-component privacy query device in this application embodiment will be described below from the perspective of hardware processing.

[0114] It should be noted that, Figure 2 The physical device corresponding to the input / output module 601 shown can be a transceiver, radio frequency circuit, communication module, and input / output (I / O) interface, etc., and the physical device corresponding to the processing module 602 can be a processor.

[0115] Figure 2 The devices shown can all have the following characteristics: Figure 3 The structure shown, when Figure 2 The intelligent federated learning cross-component privacy query device 60 shown has the following features: Figure 3 When the structure shown is used, Figure 3 The processor and transceiver in the device can perform the same or similar functions as the processing module 602 and input / output module 601 provided in the aforementioned device embodiments.

[0116] This application also relates to a chip system including at least one processor and an interface circuit. The processor includes a plurality of vector storage units. The processor is used to perform instruction and / or data interaction through the interface circuit, causing the chip system to perform the methods of any of the above embodiments. In one possible implementation, the chip system may also directly include a memory in which computer programs or computer instructions are stored. For example, the memory can be volatile memory or non-volatile memory, or may include both. The non-volatile memory can be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. The volatile memory can be random access memory (RAM), which serves as an external cache. By way of example, but not limitation, many forms of RAM are available, such as static random access memory (SRAM), dynamic random access memory (DRAM), synchronous dynamic random access memory (SDRAM), double data rate synchronous dynamic random access memory (DDR SDRAM), enhanced synchronous dynamic random access memory (ESDRAM), synchronous linked dynamic random access memory (SLDRAM), and direct rambus RAM (DRRAM). This application also relates to a processor, which includes a plurality of storage units for calling computer programs or computer instructions stored in the memory to cause the processor to execute the methods described in any of the above embodiments. For example, in the embodiments of this application, the processor is an integrated circuit chip with signal processing capabilities. For instance, the processor may be an FPGA, a general-purpose processor, a DSP, an ASIC, or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, a SoC, a CPU, a network processor (NP), a microcontroller unit (MCU), a PLD, or other integrated chips, which can implement or execute the various methods, steps, and logic block diagrams disclosed in the embodiments of this application.

[0117] In one possible implementation, this application also provides a computer-readable storage medium storing program code that, when executed on a computer, causes the computer to perform the above-described method embodiments.

[0118] This application also provides a server; please refer to [link / reference]. Figure 4 , Figure 4 This is a schematic diagram of a server structure provided in an embodiment of this application. The server 1100 can vary significantly due to different configurations or performance. It may include one or more central processing units (CPUs) 1122 (e.g., one or more processors) and memory 1132, and one or more storage media 1130 (e.g., one or more mass storage devices) for storing application programs 1142 or data 1144. The memory 1132 and storage media 1130 may be temporary or persistent storage. The program stored in the storage media 1130 may include one or more modules (not shown in the figure), each module may include a series of instruction operations on the server. Furthermore, the CPU 1122 may be configured to communicate with the storage media 1130 and execute the series of instruction operations in the storage media 1130 on the server 1100.

[0119] Server 1100 may also include one or more power supplies 1126, one or more wired or wireless network interfaces 1150, one or more input / output interfaces 1158, and / or one or more operating systems 1141, such as Windows Server, Mac OS X, Unix, Linux, FreeBSD, etc.

[0120] The steps performed by the server in the above embodiments can be based on this Figure 4 The structure of server 1100 shown. For example, as in the above embodiment, by Figure 2 The steps performed by the intelligent federated learning cross-component privacy query device 60 shown can be based on this Figure 4 The server structure is shown. For example, the central processing unit 1122 performs the following operations by calling instructions from memory 1132: The query request is obtained through input / output interface 1158; Multiple subtasks are generated based on the data source corresponding to the query request; Generate a privacy budget and sensitivity for each subtask; Based on the type of data source corresponding to each subtask and the dynamic weight of each federation component, each subtask is assigned to a federation component for execution; wherein, the type of data source is exclusive data or shared data, the exclusive data indicates that only a single federation component can access the data source, the shared data indicates that multiple federation components can access the data source, and the dynamic weight represents the real-time query capability of the federation component. Receive the noise-adding results of each federated component; wherein, the noise-adding result of each federated component is obtained by adding noise based on the intermediate results of that federated component and the privacy budget and sensitivity of the subtask corresponding to that federated component; The noisy results returned by each federated component are aggregated to obtain an aggregated result. The aggregated result is then compensated and denoised to obtain the query result.

[0121] The query results can also be output through input / output interface 1158.

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

[0123] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and modules described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

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

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

[0126] Furthermore, the functional modules in the various embodiments of this application can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can be stored in a computer-readable storage medium.

[0127] In the above embodiments, implementation can be achieved, in whole or in part, through software, hardware, firmware, or any combination thereof. When implemented in software, it can be implemented, in whole or in part, as a computer program product.

[0128] The computer program product includes one or more computer instructions. When the computer program is loaded and executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer may be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, digital subscriber line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium may be any available medium that a computer can store or a data storage device such as a server or data center that integrates one or more available media. The available medium may be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., a solid-state disk (SSD)).

[0129] The technical solutions provided in the embodiments of this application have been described in detail above. Specific examples have been used in the embodiments of this application to illustrate the principles and implementation methods of the embodiments of this application. The description of the above embodiments is only for the purpose of helping to understand the methods and core ideas of the embodiments of this application. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of the embodiments of this application. Therefore, the content of this specification should not be construed as a limitation on the embodiments of this application.

Claims

1. A method for cross-component privacy query in intelligent federated learning, characterized in that, The method includes: Get the query request; Multiple subtasks are generated based on the data source corresponding to the query request; Generate a privacy budget and sensitivity for each subtask; Based on the type of data source corresponding to each subtask and the dynamic weight of each federation component, each subtask is assigned to a federation component for execution; wherein, the type of data source is exclusive data or shared data, the exclusive data indicates that only a single federation component can access the data source, the shared data indicates that multiple federation components can access the data source, and the dynamic weight represents the real-time query capability of the federation component. Receive the noise-adding results of each federated component; wherein, the noise-adding result of each federated component is obtained by adding noise based on the intermediate results of that federated component and the privacy budget and sensitivity of the subtask corresponding to that federated component; The noisy results returned by each federated component are aggregated to obtain an aggregated result. The aggregated result is then compensated and denoised to obtain the query result.

2. The intelligent federated learning cross-component privacy query method as described in claim 1, wherein generating multiple sub-tasks based on the data source corresponding to the query request includes: A query syntax tree is constructed based on the query request. The query syntax tree includes a root node, multiple first-level child nodes, and leaf nodes corresponding to each first-level child node. The root node is used to store the operation type of the query request. The multiple first-level child nodes include at least a first-level child node for storing the data source corresponding to the query request, a first-level child node for storing the query conditions corresponding to the query request, and a first-level child node for storing the aggregation conditions corresponding to the query request. The leaf nodes corresponding to each first-level child node are used to store the atomic elements of their respective first-level child nodes. Traverse the first-level child nodes and leaf nodes corresponding to the data sources in the query syntax tree to determine all data sources included in the query request, as well as the federated components to which each data source belongs; The query request is divided into multiple subtasks based on each of the data sources, and each subtask corresponds to a data source.

3. The intelligent federated learning cross-component privacy query method as described in claim 1, wherein generating a privacy budget and sensitivity for each subtask includes: The privacy budget for each subtask is determined based on a preset global privacy policy or the parameters specified in the query request. The difference between the maximum and minimum values ​​of each field in the data source corresponding to any subtask is used as the sensitivity of that subtask.

4. The intelligent federated learning cross-component privacy query method as described in claim 1, wherein the step of allocating each subtask to each federated component for execution based on the type of data source corresponding to each subtask and the dynamic weights of each federated component includes: Assign subtasks with a data source type of exclusive data to the first target federation component, which is a federation component that has a unique data source corresponding to the subtask. Subtasks of shared data types are assigned to a second target federation component, which is the federation component with the highest dynamic weight among all federation components that have the data source corresponding to the subtask; wherein, the dynamic weight is determined based on the current CPU utilization, memory usage, and network latency of the federation component.

5. The intelligent federated learning cross-component privacy query method as described in claim 4, wherein assigning the subtask with a data source type of exclusive data to the first target federated component includes: A subtask queue is constructed for the first target federated component. When the current concurrency of the first target federated component exceeds the preset maximum concurrency, the subtasks are stored in the subtask queue. When the current concurrency of the first target federated component is less than the maximum concurrency, the subtasks are allocated sequentially based on the subtask queue.

6. The intelligent federated learning cross-component privacy query method as described in claim 4, further comprising, after assigning subtasks of shared data types to the second target federated component: The dynamic weights of each federated component with the data source corresponding to the subtask are monitored in real time. When the difference between the dynamic weight of any other federated component and the dynamic weight of the second target federated component exceeds a preset value, the subtask is migrated to the second target federated component.

7. A smart federated learning cross-component privacy query device, characterized in that, The device includes: The input / output module is configured to retrieve query requests; The processing module is configured to generate multiple subtasks for the data source corresponding to the query request; Generate a privacy budget and sensitivity for each subtask; Based on the type of data source corresponding to each subtask and the dynamic weight of each federation component, each subtask is assigned to each federation component for execution; wherein, the type of data source is exclusive data or shared data, the exclusive data indicates that only a single federation component has the data source, the shared data indicates that multiple federation components have the data source, and the dynamic weight represents the real-time query capability of the federation component. Receive the noise-adding results of each federated component; wherein, the noise-adding result of each federated component is obtained by adding noise based on the intermediate results of that federated component and the privacy budget and sensitivity of the subtask corresponding to that federated component; The noisy results returned by each federated component are aggregated to obtain an aggregated result. The aggregated result is then compensated and denoised to obtain the query result.

8. A computing device, characterized in that, It includes 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 method of any one of claims 1-6.

9. A computer-readable storage medium, characterized in that, It includes instructions that, when run on a computer, cause the computer to perform the method as described in any one of claims 1-6.

10. A computer program product comprising computer instructions, characterized in that, When executed by a processor, the computer instructions implement the method described in any one of claims 1-6.

Images