Privacy computing method and apparatus, device, and medium

Abstract

The present application discloses a privacy computing method and apparatus, a device, and a medium, for use in performing privacy computing by means of a privacy algorithm designed on the basis of another privacy computing platform, so that privacy algorithms designed on the basis of different privacy computing platforms can be interconnected and interwork. According to the present application, when a privacy computing task running instruction is received, an algorithm identifier carried in the privacy computing task running instruction can be identified; and if a privacy algorithm corresponding to the algorithm identifier is identified as a privacy algorithm designed on the basis of another privacy computing platform, an algorithm mirror image of the algorithm identifier obtained from a mirror image repository with which a connection is pre-established is run in a containerization mode, and corresponding privacy computing is performed on the basis of a privacy algorithm in the algorithm mirror image. On this basis, privacy computing can be carried out by means of a privacy algorithm designed on the basis of another privacy computing platform, so that the purpose of interconnection and interworking between privacy algorithms designed on the basis of different privacy computing platforms can be achieved.

Description

A privacy computing method, device, equipment and medium

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims priority to the Chinese patent application filed with the State Intellectual Property Office of China on August 28, 2023, with application number 202311094053.X and application name “A Privacy Computing Method, Device, Equipment and Medium”, the entire contents of which are incorporated by reference into this application. Technical Field

[0003] The present application relates to the field of data security technology, and in particular to a privacy computing method, apparatus, device and medium. Background Art

[0004] Privacy computing (Privacy compute or Privacy computing) refers to a collection of technologies that implement data analysis and calculations while protecting the data itself from external leakage, so as to achieve the goal of "available but invisible" data, and realize the transformation and release of data value while fully protecting data and privacy security.

[0005] With growing industry awareness of data protection and tightening privacy regulations, privacy computing, due to its "available, invisible" nature, has garnered widespread attention. Numerous technology vendors have launched industry-specific privacy computing algorithms (referred to as privacy algorithms). While this plethora of privacy algorithms has enriched market options, it has also introduced new challenges. For example, privacy algorithms released by different technology vendors are often designed and implemented based on different privacy computing platforms. These algorithms often lack information exchange, transforming "data silos" into "computing silos."

[0006] Therefore, interoperability between privacy algorithms designed on different privacy computing platforms has become a major pain point in the industry. How to use privacy algorithms designed on other privacy computing platforms for privacy computing and enable interoperability between privacy algorithms designed on different privacy computing platforms is a technical challenge that urgently needs to be addressed.

[0007] Summary of the Invention

[0008] This application provides a privacy computing method, apparatus, device, and medium for performing privacy computing using privacy algorithms designed on other privacy computing platforms, so that privacy algorithms designed on different privacy computing platforms can be interconnected.

[0009] In a first aspect, the present application provides a privacy-preserving computing method, the method comprising:

[0010] Receive a privacy-preserving computing task execution instruction, and identify an algorithm identifier carried in the privacy-preserving computing task execution instruction;

[0011] If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, the algorithm image of the algorithm identifier obtained from a pre-established image repository is run in a containerized manner, and corresponding privacy computing is performed based on the privacy algorithm in the algorithm image; wherein, the algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

[0012] In a second aspect, the present application provides a privacy-preserving computing device, comprising:

[0013] A receiving module, configured to receive a privacy-preserving computing task execution instruction and identify an algorithm identifier carried in the privacy-preserving computing task execution instruction;

[0014] The running module is used to run the algorithm image of the algorithm identifier obtained from a pre-established image repository in a containerized manner if it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, and perform corresponding privacy computing based on the privacy algorithm in the algorithm image; wherein the algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

[0015] In a third aspect, the present application provides an electronic device, which includes at least a processor and a memory, and the processor is used to implement the steps of any of the above methods when executing a computer program stored in the memory.

[0016] In a fourth aspect, the present application provides a computer-readable storage medium storing a computer program, which implements the steps of any of the above methods when executed by a processor.

[0017] Since this application can identify the algorithm identifier carried in the privacy computing task running instruction when receiving the privacy computing task running instruction; if it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, then the algorithm image with the algorithm identifier obtained from the image repository with a pre-established connection is run in a containerized manner, and the corresponding privacy computing is performed based on the privacy algorithm in the algorithm image; wherein, the algorithm image can be generated based on the privacy algorithm corresponding to the algorithm identifier and the set algorithm image generation standard. Based on this, privacy computing can be performed using privacy algorithms designed by other privacy computing platforms, so that privacy algorithms designed based on different privacy computing platforms can be interconnected.

[0018] Furthermore, in related technologies, privacy algorithms currently released by various technology vendors require specific algorithm engines to drive their operation. Privacy algorithms, algorithm engines, and privacy computing platforms are strongly bound together. Each privacy computing platform's algorithm engine services are independently designed, and the methods for submitting computational tasks, obtaining computational results, and passing algorithm parameters to different algorithm engine services vary. Consequently, a particular vendor's algorithm engine cannot be deployed and used by other privacy computing platforms (also known as heterogeneous privacy computing platforms, or heterogeneous platforms). Furthermore, algorithm engine use also presents challenges with algorithm security verification. The security authentication methods for algorithm engines on various heterogeneous platforms vary, making a universal, unified approach impossible. All of these factors make it impossible to use privacy algorithms designed on other privacy computing platforms (heterogeneous privacy computing platforms) for privacy computing, preventing interoperability between privacy algorithms designed on different privacy computing platforms. This application can separate the privacy algorithm from the algorithm engine and the privacy computing platform, isolate the privacy algorithm part, and use the algorithm image of the privacy algorithm in a containerized manner to drive the execution of the privacy algorithm, so as to achieve privacy computing using privacy algorithms designed by other privacy computing platforms, so that privacy algorithms designed based on different privacy computing platforms can be interconnected.

[0019] In addition, this application can separate the privacy algorithm from the algorithm engine and the privacy computing platform, separate the privacy algorithm part, make the privacy algorithm into an algorithm image, and drive the execution of the privacy algorithm by running the algorithm image of the privacy algorithm in a containerized manner. It can be considered that the privacy algorithm is made into a plug-in and can be used by other heterogeneous privacy computing platforms in a pluggable manner, which can quickly and flexibly realize the interconnection between privacy algorithms designed by different privacy computing platforms. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] In order to more clearly illustrate the implementation methods in the embodiments of the present application or related technologies, the following is a brief introduction to the drawings required for use in the embodiments or related technology descriptions. Obviously, the drawings described below are some embodiments of the present application. For ordinary technicians in this field, other drawings can also be obtained based on these drawings.

[0021] FIG1 shows a schematic diagram of a first privacy computing process provided by some embodiments;

[0022] FIG2 shows a schematic diagram of a second privacy computing process provided by some embodiments;

[0023] FIG3 shows a schematic diagram of a third privacy computing process provided by some embodiments;

[0024] FIG4 shows a schematic diagram of a fourth privacy computing process provided by some embodiments;

[0025] FIG5 shows a schematic diagram of a fifth privacy computing process provided by some embodiments;

[0026] FIG6 shows a schematic diagram of a sixth privacy computing process provided by some embodiments;

[0027] FIG7 shows a schematic diagram of a seventh privacy computing process provided by some embodiments;

[0028] FIG8 shows a schematic diagram of an eighth privacy computing process provided by some embodiments;

[0029] FIG9 shows a schematic diagram of a component instance state provided by some embodiments;

[0030] FIG10 shows a schematic diagram of a ninth privacy computing process provided by some embodiments;

[0031] FIG11 shows a schematic diagram of a tenth privacy computing process provided by some embodiments;

[0032] FIG12 shows a schematic diagram of an eleventh privacy computing process provided by some embodiments;

[0033] FIG13 is a schematic diagram showing the relationship between a privacy computing task and a component instance provided by some embodiments;

[0034] FIG14 shows a schematic diagram of a container loading process provided by some embodiments;

[0035] FIG15 shows a schematic diagram of a privacy-preserving computing device provided by some embodiments;

[0036] FIG16 shows a schematic diagram of an electronic device provided by some embodiments. DETAILED DESCRIPTION

[0037] In order to enable privacy computing using privacy algorithms designed on other privacy computing platforms and to enable the interconnection and intercommunication between privacy algorithms designed on different privacy computing platforms, this application provides a privacy computing method, apparatus, device, and medium.

[0038] In order to make the purpose and implementation of this application clearer, the exemplary implementation of this application will be clearly and completely described below in conjunction with the drawings in the exemplary embodiments of this application. Obviously, the described exemplary embodiments are only part of the embodiments of this application, not all of the embodiments.

[0039] It should be noted that the brief descriptions of terms in this application are only for the purpose of facilitating the understanding of the embodiments described below, and are not intended to limit the embodiments of this application. Unless otherwise specified, these terms should be understood according to their ordinary and usual meanings.

[0040] In the specification and claims of this application and the accompanying drawings, the terms "first," "second," "third," etc. are used to distinguish similar or similar objects or entities, and are not necessarily intended to limit a particular order or sequence, unless otherwise noted. It should be understood that the terms used in this manner are interchangeable under appropriate circumstances.

[0041] The terms "comprise," "include," and "have," and any variations thereof, are intended to cover but not exclude inclusion; for example, a product or device comprising a list of components is not necessarily limited to all the components expressly listed but may include other components not expressly listed or inherent to such product or device.

[0042] The term "module" refers to any known or later developed hardware, software, firmware, artificial intelligence, fuzzy logic, or combination of hardware and / or software code that is capable of performing the functionality associated with that element.

[0043] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some or all of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the scope of the technical solutions of the embodiments of the present application.

[0044] All implementation methods of the embodiments of this application comply with the relevant provisions of national laws and regulations regarding the acquisition, storage, use, and processing of data.

[0045] Example 1:

[0046] FIG1 shows a schematic diagram of a first privacy computing process provided by some embodiments. As shown in FIG1 , the process includes the following steps:

[0047] S101: Receive a privacy-preserving computing task execution instruction and identify an algorithm identifier carried in the privacy-preserving computing task execution instruction.

[0048] The privacy computing method provided in the embodiments of the present application is applied to an electronic device, which may be a PC, a mobile terminal, or a server. Optionally, the electronic device may be a privacy computing device that stores a privacy algorithm designed based on a privacy computing platform.

[0049] In one possible implementation, when privacy-preserving computing is required, an electronic device (privacy-preserving computing device) can, upon receiving a privacy-preserving computing task execution instruction, identify the algorithm identifier carried in the privacy-preserving computing task execution instruction. This application does not specifically limit the triggering method for the privacy-preserving computing task execution instruction. For example, the privacy-preserving computing task execution instruction can be triggered when a staff member clicks a button such as "Start Calculation" displayed on the electronic device, thereby receiving the privacy-preserving computing task execution instruction. Alternatively, the privacy-preserving computing task execution instruction can be triggered upon receiving a start request to start a privacy-preserving computing task from another privacy-preserving computing device, thereby receiving the privacy-preserving computing task execution instruction.

[0050] Optionally, the number of algorithm identifiers carried in a privacy-preserving computing task execution instruction can be one or more. This application does not specifically limit the number of algorithm identifiers carried in a privacy-preserving computing task execution instruction. Furthermore, this application does not specifically limit the specific content of the algorithm identifier carried in a privacy-preserving computing task execution instruction. For example, the algorithm identifier may include the algorithm name, algorithm type, algorithm version, etc., and can be flexibly set as needed.

[0051] S102: If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, then the algorithm image of the algorithm identifier obtained from a pre-established image repository is run in a containerized manner, and corresponding privacy computing is performed based on the privacy algorithm in the algorithm image; wherein, the algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

[0052] In a possible implementation, for any algorithm identifier carried in the privacy computing task execution instruction, if it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, in order to be able to use the privacy algorithm designed by other privacy computing platforms for privacy computing (for the convenience of description, the above-mentioned electronic device can be referred to as the user, and the device where the above-mentioned other privacy computing platform is located can be referred to as the publisher), so that the privacy algorithms designed based on different privacy computing platforms can be interconnected, the algorithm image of the algorithm identifier obtained from the pre-established image repository can be run in a containerized manner, and the corresponding privacy computing can be performed based on the privacy algorithm in the algorithm image. The algorithm image of the above-mentioned algorithm identifier can be an algorithm image generated by the publisher based on the privacy algorithm corresponding to the algorithm identifier and the set algorithm image generation standard. Optionally, the privacy algorithm corresponding to the above-mentioned algorithm identifier can belong to the publisher, that is, the privacy algorithm corresponding to the above-mentioned algorithm identifier can be a privacy algorithm launched by the publisher's technology manufacturer. The algorithm image generation standard can be flexibly set according to demand, and this application does not make specific restrictions on this.

[0053] Optionally, when performing privacy computing based on the privacy algorithm in the algorithm image, the privacy computing can be performed jointly using the privacy algorithm in the algorithm image (a privacy algorithm designed based on another privacy computing platform) and the privacy algorithm stored in the electronic device (a privacy algorithm designed based on the user's own privacy computing platform). This application does not specifically limit the specific process of performing privacy computing. This application also does not specifically limit the number of privacy algorithms participating in the joint privacy computing process (such as the number of privacy algorithms designed based on another privacy computing platform).

[0054] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to Figure 2, Figure 2 shows a schematic diagram of the second privacy computing process provided by some embodiments, which includes the following steps:

[0055] S201: Each publisher generates an algorithm image of its own privacy algorithm based on its own privacy algorithm and the set algorithm image generation standard, and publishes its own algorithm image and corresponding algorithm identifier to the image repository (public storage environment).

[0056] S202: The user receives a privacy-preserving computing task execution instruction and identifies each algorithm identifier carried in the privacy-preserving computing task execution instruction. For each algorithm identifier, if the corresponding privacy-preserving algorithm is identified as a privacy-preserving algorithm designed based on another privacy-preserving computing platform, the user executes the algorithm image corresponding to the algorithm identifier obtained from a pre-established image repository in a containerized manner. The user then performs privacy-preserving computing based on the privacy-preserving algorithm in each algorithm image.

[0057] Since this application can identify the algorithm identifier carried in the privacy computing task running instruction when receiving the privacy computing task running instruction; if it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, then the algorithm image with the algorithm identifier obtained from the image repository with a pre-established connection is run in a containerized manner, and the corresponding privacy computing is performed based on the privacy algorithm in the algorithm image; wherein, the algorithm image can be generated based on the privacy algorithm corresponding to the algorithm identifier and the set algorithm image generation standard. Based on this, privacy computing can be performed using privacy algorithms designed by other privacy computing platforms, so that privacy algorithms designed based on different privacy computing platforms can be interconnected.

[0058] Furthermore, in related technologies, privacy algorithms currently released by various technology vendors require specific algorithm engines to drive their operation. Privacy algorithms, algorithm engines, and privacy computing platforms are strongly bound together. Each privacy computing platform's algorithm engine services are independently designed, and the methods for submitting computational tasks, obtaining computational results, and passing algorithm parameters to different algorithm engine services vary. Consequently, a particular vendor's algorithm engine cannot be deployed and used by other privacy computing platforms (also known as heterogeneous privacy computing platforms, or heterogeneous platforms). Furthermore, algorithm engine use also presents challenges with algorithm security verification. The security authentication methods for algorithm engines on various heterogeneous platforms vary, making a universal, unified approach impossible. All of these factors make it impossible to use privacy algorithms designed on other privacy computing platforms (heterogeneous privacy computing platforms) for privacy computing, preventing interoperability between privacy algorithms designed on different privacy computing platforms. This application can separate the privacy algorithm from the algorithm engine and the privacy computing platform, isolate the privacy algorithm part, and use the algorithm image of the privacy algorithm in a containerized manner to drive the execution of the privacy algorithm, so as to achieve privacy computing using privacy algorithms designed by other privacy computing platforms, so that privacy algorithms designed based on different privacy computing platforms can be interconnected.

[0059] In addition, this application can separate the privacy algorithm from the algorithm engine and the privacy computing platform, separate the privacy algorithm part, make the privacy algorithm into an algorithm image, and drive the execution of the privacy algorithm by running the algorithm image of the privacy algorithm in a containerized manner. It can be considered that the privacy algorithm is made into a plug-in and can be used by other heterogeneous privacy computing platforms in a pluggable manner, which can quickly and flexibly realize the interconnection between privacy algorithms designed by different privacy computing platforms.

[0060] Example 2:

[0061] In order to quickly and accurately perform privacy computing using privacy algorithms designed by other privacy computing platforms, based on the above embodiments, in the embodiments of this application, the algorithm image corresponding to the algorithm identifier obtained from a pre-established image repository in a containerized manner includes:

[0062] Identifying the algorithm image operation standard indicated by the algorithm image generation standard;

[0063] According to the algorithm image running standard, the algorithm image is run in a containerized manner.

[0064] In a possible implementation, when running an algorithm image, the algorithm image running standard indicated in the corresponding algorithm image generation standard may be first identified, and the algorithm image may be run in a containerized manner according to the algorithm image running standard.

[0065] Optionally, when running the algorithm image in a containerized manner according to the algorithm image operation standard, the target container's operating environment may be configured according to the container's required configuration information carried in the algorithm image operation standard to start the target container, thereby realizing the operation of the corresponding algorithm image in a containerized manner. This application does not specifically limit the configuration information required for the container, and it can be flexibly set according to demand. Exemplarily, the container's required configuration information carried in the algorithm image operation standard may include: image system configuration definition information of the algorithm component (algorithm), image task configuration definition information of the algorithm component, etc.

[0066] The image system configuration definition information for an algorithm component refers to the basic system configuration that needs to be configured when a heterogeneous platform (other privacy computing platforms) uses the algorithm component container service created by the algorithm image. This configuration can be set using the system's ENV variables (environment variables), and the corresponding algorithm component can read ENV to load the required system configuration during runtime. The image system configuration definition information is mainly divided into system interface self-description information and algorithm component configuration self-description information.

[0067] Refer to Table 1, which shows a schematic table of system interface self-description information provided by some embodiments. The system interface self-description information may include fields such as the storage layer service address, storage layer service address identifier, scheduling layer callback address, scheduling layer callback address identifier, transmission service address, and transmission service address identifier. Optionally, considering that existing privacy computing platforms are often coupled with an algorithm engine, to ensure compatibility with existing privacy computing platforms, the system interface self-description information may also include the computing engine service address and computing engine service address identifier. Based on a privacy computing platform configured with an algorithm engine configured with the computing engine service address, the algorithm image obtained from the image repository may be run in a containerized manner. Optionally, when the privacy computing platform does not have an algorithm engine configured, the algorithm image obtained from the image repository may also be run in a containerized manner, which is not specifically limited in this application. Optionally, the system interface self-description information may also include description information or remarks for each field. Exemplarily, the description information or remarks for the scheduling layer callback address (referred to as "description / remarks" in the table) may include: callback via an interface, callback via container execution results, or other methods. This application does not make specific limitations on the fields in the system interface self-description information and the description information or remarks of each field, and can be flexibly set according to needs. In addition, the system interface self-description information can also include optional requirements for whether each field must be set or can be set or not. For example, when the optionality of a certain field is required, it means that the content of this field must be set. For example, the optionality of the storage layer service address is required, which means that the storage layer service address must be set so that the operating environment of the container can be configured based on the storage layer service address. When the optionality of a certain field is optional, it means that the content of this field can be set or not. For example, the optionality of the computing engine service address field is optional, which means that the computing engine service address can be set or not.

[0068] Table 1

[0069] Refer to Table 2, which shows a schematic table of self-description information of an algorithm component configuration provided by some embodiments, wherein the self-description information of the algorithm component configuration may include: the identification document (ID) of the privacy computing task in which the algorithm component participates, the node ID of the current node, the organization ID to which the current node belongs, the session ID required by the transmission SDK, the link ID, the data set authorization token (token), the log path (log address information), the number of parallel uploads and downloads of the storage SDK, the block size of the storage SDK uploads and downloads data, and other fields, which will not be repeated here.

[0070] Table 2

[0071] Optionally, the image task configuration definition information of the algorithm component refers to: the algorithm-related configurations that need to be configured when the heterogeneous platform uses the algorithm component container service created by the algorithm image. The image task configuration definition information of the algorithm component may include: the name of the algorithm component to be run, the algorithm component parameters, the input and output of the algorithm and other fields. Among them, referring to Tables 3 to 6, Table 3 shows a schematic table of algorithm component names provided by some embodiments, Table 4 shows a schematic table of algorithm component parameters provided by some embodiments, Table 5 shows a schematic table of algorithm component inputs provided by some embodiments, and Table 6 shows a schematic table of algorithm component outputs provided by some embodiments, which will not be repeated here.

[0072] Table 3

[0073] Table 4

[0074] Table 5

[0075] Table 6

[0076] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to Figure 3, Figure 3 shows a schematic diagram of the third privacy computing process provided by some embodiments, which includes the following steps:

[0077] First, the electronic device (privacy computing device, user) receives the privacy computing task running instruction and identifies each algorithm identifier carried in the privacy computing task running instruction. For each algorithm identifier, if the privacy algorithm corresponding to the algorithm identifier is identified as a privacy algorithm designed based on other privacy computing platforms, the scheduling layer of the electronic device can obtain the algorithm image of the algorithm identifier from the image repository with a pre-established connection. Identify the algorithm image running standard indicated by the algorithm image generation standard, configure the system configuration and algorithm parameters required by the container in the container ENV according to the configuration information required for the container carried in the algorithm image running standard, configure the operating environment of the target container, and start the target container (algorithm container) by calling the application container engine (docker) or kubernetes (k8s), and run the corresponding algorithm image in a containerized manner.

[0078] In a containerized manner, after running the algorithm image of each algorithm identifier (after the algorithm container is started), you can execute the default startup command to run the entry py file (Python script file). Optionally, you can execute the entry py file in the following order:

[0079] (1) Obtain the system configuration (mirror system configuration definition information of the algorithm component) from ENV, for example, obtain the configuration information of the transmission service address, the configuration information of the storage layer service address, the configuration information of the computing engine service address, the privacy computing task ID, the node information of all participants in the current privacy computing task, etc.

[0080] (2) Based on the configuration information of the transmission service address, all participating nodes initialize the transmission session information. For example, the initialization transmits information such as the session ID required by the SDK.

[0081] (3) Initialize the storage session information based on the configuration information of the storage layer service address.

[0082] (4) Obtain algorithm parameters from ENV, such as the operating parameters of algorithm components, input information and output information of the algorithm, etc.

[0083] (5) Reading data, such as reading the data or model input by the algorithm.

[0084] (6) Initialize the algorithm, pass in the parameters and input data required by the algorithm, start running the algorithm mirror of each participant's privacy algorithm, and perform interconnected privacy computing.

[0085] Among them, the privacy algorithm can be an algorithm of the Intersection, Hetero_Logistic_Regression and other algorithm types, and this application does not make specific limitations on this.

[0086] (7) After any privacy algorithm is completed, the results of the privacy algorithm (data, model, report results, etc.) can be persisted to the storage service. For example, the results can be stored in the S3 database (storage SDK). Optionally, the results (including sub-results during the algorithm execution) can also be transferred to an external service (transfer server) (transfer SDK), and based on the external service, the privacy algorithm can be interconnected with the privacy algorithms of other privacy computing platforms.

[0087] For ease of understanding, the privacy computing process provided by this application is further explained below through a specific embodiment. Referring to Figure 4, Figure 4 shows a schematic diagram of the fourth privacy computing process provided by some embodiments, which includes the following steps:

[0088] S401: Receive a privacy-preserving computing task execution instruction and identify the algorithm identifier carried in the privacy-preserving computing task execution instruction.

[0089] S402: If it is identified that the privacy algorithm corresponding to the above-mentioned algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, then the algorithm image operation standard indicated by the algorithm image generation standard is identified; according to the configuration information required for the container carried in the algorithm image operation standard, the operating environment of the target container is configured, and the target container is started. In a containerized manner, the algorithm image of the algorithm identifier obtained from the image repository with a pre-established connection is run, and corresponding privacy calculations are performed based on the privacy algorithm in the algorithm image.

[0090] Compared to each privacy computing platform generating an algorithm image of a privacy algorithm based on different benchmarks (such as different platform design methods, etc.), which results in the inability of privacy algorithms of different privacy computing platforms to interconnect and communicate with each other, in the embodiments of the present application, each privacy computing platform can adopt a unified algorithm image generation standard to quickly create its own privacy algorithm as an algorithm image, publish it to a unified image repository, and provide it for use by heterogeneous privacy computing platforms through a unified algorithm image publishing and discovery method. When using the privacy algorithms of other heterogeneous privacy computing platforms, each privacy computing platform can also adopt a unified algorithm image operation standard to run the algorithm image in a containerized manner, such as supporting the use of system ENV to configure various parameters into the container's operating environment, and automatically running the container-configured startup file to run the algorithm task process when the container starts, etc., thereby realizing the use of privacy algorithms of other heterogeneous privacy computing platforms and achieving interconnection and interoperability between privacy algorithms of different privacy computing platforms.

[0091] Example 3:

[0092] To quickly perform privacy-preserving computing, based on the above embodiments, in this embodiment of the present application, after identifying the algorithm identifier carried in the privacy-preserving computing task execution instruction, and before configuring the target container's operating environment based on the container configuration information carried in the algorithm image execution standard, the method further includes:

[0093] Identify a container communication mode carried in the tag information of the algorithm image, and obtain the target container based on the container communication mode.

[0094] In one possible implementation, to standardize algorithm image generation standards and facilitate interoperability between privacy algorithms designed based on different privacy computing platforms, the algorithm image definitions and algorithm component definitions within the algorithm image generation standards can be standardized. This standardization of algorithm image definitions can include unified specifications for algorithm image naming, image tags, directory structure information for log addresses, container communication methods, and security protection measures for ensuring algorithm images. The following describes the details of the algorithm image definition standardization.

[0095] (a) Naming standardization of algorithm images

[0096] Optionally, the algorithm image can be named in the following format:

[0097] / <developer> / <image-name> : <tag>.

[0098] In this section, "developer" represents the developer identifier of the algorithm component, which can be a company name or organization name. Alliances and other organizations can standardize the identifiers of various technology vendors (developers), and this will not be discussed here. "image-name" represents the function, classification, and other important information of the algorithm component to be reflected, such as longitudinal logistic regression (hetero-lr), PSI based on DH key negotiation (dh-psi), and the FATE algorithm package (fate-collection). "Tag" represents the algorithm version number, which follows the naming convention of major.minor.patch[-state]. For example, the algorithm version number can be 1.0.0, 1.0.1-beta, and so on. "major" in the version number represents the major version number of the algorithm; changes in it usually indicate significant changes to the algorithm. "minor" represents the minor version number of the algorithm, which usually only reflects some major changes. "patch" usually represents a patch version. "state" represents the state of the algorithm. The state of the algorithm is optional and can be a data set describing the current state of the system. This application does not specifically limit this. Generally, after an algorithm image is published to the image repository, its name and other information cannot be changed.

[0099] (b) Image label standardization of algorithm images

[0100] Optionally, the image tag of the algorithm image can be uniformly added with key-value pairs such as LABEL k1=v1, k2=v2 to provide more information for the algorithm image. The specific meaning of the image tag can be clearly stated in the external documentation.

[0101] (c) Standardization of the directory structure information of the log address of the algorithm mirror

[0102] Optionally, the directory structure information of the algorithm image's log address (log directory) can be specified in an image tag, etc., using the Dockerfile WORKDIR method. See Table 7, which shows a schematic table of image tag information provided by some embodiments. The directory of the log address (log file address) can be specified in the image tag information as / home / admin / app / logs, etc., which will not be repeated here.

[0103] Table 7

[0104] Optionally, the electronic device may identify log address information carried in the algorithm image (such as image tag information of the algorithm image); and store the operation log generated by running the algorithm image according to the log address information.

[0105] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to Figure 5, Figure 5 shows a schematic diagram of the fifth privacy computing process provided by some embodiments, which includes the following steps:

[0106] S501: Receive a privacy-preserving computing task execution instruction, identify an algorithm identifier carried in the privacy-preserving computing task execution instruction, and if the privacy-preserving algorithm corresponding to the algorithm identifier is identified as a privacy-preserving algorithm designed based on another privacy-preserving computing platform, execute an algorithm image corresponding to the algorithm identifier obtained from a pre-established image repository in a containerized manner. Perform the corresponding privacy-preserving computing based on the privacy-preserving algorithm in the algorithm image.

[0107] S502: Identify the log address information carried by the algorithm image; and store the operation log generated by running the algorithm image according to the log address information.

[0108] (d) Standardization of container communication methods for algorithm images

[0109] Optionally, in order to make the container accessible to the outside, a Transmission Control Protocol / Internet Protocol (TCP / IP) socket or the like may be used to expose internal services by listening to ports. The container port number may be specified in the image tag information of the algorithm image so that the container is accessible to the outside. Referring to Table 8, Table 8 shows a schematic table of image tag information provided by some embodiments. The container port number may be specified in the image tag information. Subsequent users may identify the container port number (container communication method) carried in the tag information of the algorithm image, obtain the target container based on the container port number, and configure the target container's operating environment according to the container's required configuration information carried in the algorithm image operating standard, thereby starting the target container and running the corresponding algorithm image. The steps are not repeated here.

[0110] Table 8

[0111] Optionally, for possible port number (container port number) conflicts, the capabilities of the infrastructure (such as K8S) can be used to resolve the port number conflict problem. Existing technologies can be used to resolve the port number conflict problem, which will not be described in detail here.

[0112] Optionally, internal services can be exposed by using Unix Domain Socket technology, such as monitoring local socket files, and external services can also be accessed through socket files. This method (Unix file) can shield the details of the network architecture, but requires algorithm component support services to implement traffic forwarding, and can flexibly and accurately start the target container. Refer to Table 9, which shows a mirror label schematic table provided by some embodiments. Among them, the algorithm component support service will be introduced in subsequent embodiments and will not be repeated here.

[0113] Table 9

[0114] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to Figure 6, Figure 6 shows a schematic diagram of the sixth privacy computing process provided by some embodiments, which includes the following steps:

[0115] S601: Receive a privacy-preserving computing task execution instruction and identify the algorithm identifier carried in the privacy-preserving computing task execution instruction.

[0116] S602: If the privacy algorithm corresponding to the algorithm identifier is identified as a privacy algorithm designed based on another privacy computing platform, the container communication method carried in the tag information of the algorithm image is identified. Based on the container communication method, a target container is obtained. The algorithm image operation standard indicated by the algorithm image generation standard is identified. Based on the container configuration information carried in the algorithm image operation standard, the operating environment of the target container is configured. The target container is started and the algorithm image with the algorithm identifier obtained from a pre-established image repository is executed in a containerized manner. The corresponding privacy computing is performed based on the privacy algorithm in the algorithm image.

[0117] (e) Standardization of protection measures to ensure the security of algorithm images

[0118] Optionally, to prevent tampering with the privacy algorithm and other features within the algorithm image and ensure the security of privacy-preserving computing, the publisher (other privacy-preserving computing platforms) can provide benchmark verification data corresponding to the algorithm image when publishing the algorithm image. For example, the benchmark verification data can be the algorithm image's SHA256 digest value, image signature, etc., though this application does not impose specific limitations on this.

[0119] Optionally, after the user (the above-mentioned electronic device) recognizes that the privacy algorithm corresponding to the algorithm identifier carried in the privacy computing task running instruction is a privacy algorithm designed based on other privacy computing platforms, before running the algorithm image corresponding to the algorithm identifier obtained from the image repository in a containerized manner, it can also obtain the data to be verified carried by the algorithm image, and compare the data to be verified with the benchmark verification data for the algorithm image provided by other privacy computing platforms. Exemplarily, the sha256 summary value, image signature, etc. carried by the algorithm image can be compared with the benchmark verification data (benchmark sha256 summary value, benchmark image signature, etc.) for the algorithm image provided by other privacy computing platforms. If the comparison result is that the data to be verified is consistent with the benchmark verification data, it can be considered that the privacy algorithm, etc. in the algorithm image has not been tampered with and is safe, and the subsequent steps of running the algorithm image corresponding to the algorithm identifier obtained from the image repository in a containerized manner can be performed. On the other hand, if the data to be verified is inconsistent with the baseline verification data, it can be considered that the privacy algorithm in the algorithm image is suspected of being tampered with. The step of obtaining the algorithm image corresponding to the algorithm identifier from the image repository in a containerized manner can be omitted. Optionally, a set security warning prompt message can be output, which is not specifically limited in this application. Optionally, the process of the publisher adding image signature information and the user verifying the image signature information can be implemented based on notary services, etc., which will not be repeated here.

[0120] In one possible implementation, in order to ensure the security of privacy computing, after the user (the above-mentioned electronic device) recognizes that the privacy algorithm corresponding to the algorithm identifier carried in the privacy computing task execution instruction is a privacy algorithm designed based on other privacy computing platforms, before running the algorithm image corresponding to the algorithm identifier obtained from the image repository in a containerized manner, it can also use open source or self-developed tools to perform a Common Vulnerabilities & Exposures (CVE) vulnerability scan based on the situation of its own infrastructure, that is, perform a vulnerability scan on the algorithm image. Optionally, if the scan result is a vulnerability with no set security threat level, it can be considered that the algorithm image has no vulnerability security threat, and the subsequent step of running the algorithm image with the corresponding algorithm identifier obtained from the image repository in a containerized manner can be performed. On the contrary, if the scan result is a vulnerability with a set security threat level, it can be considered that the algorithm image has a vulnerability security threat and the algorithm image has security issues. The subsequent step of running the algorithm image with the corresponding algorithm identifier obtained from the image repository in a containerized manner can be omitted. For example, a set security warning prompt information can be output, etc. This application does not make specific limitations on this.

[0121] The security threat level can be flexibly set according to needs, and this application does not impose specific restrictions on this. For example, when the security threat level is set to medium, high, severe, and high risk, if the scan result shows that there are no vulnerabilities with a security threat level of medium, high, severe, or high risk, then the algorithm image can be considered to have no vulnerability security threats. If the scan result shows that there are vulnerabilities with a security threat level of medium, high, severe, or high risk, then the algorithm image can be considered to have vulnerability security threats.

[0122] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to FIG7 , FIG7 shows a schematic diagram of a seventh privacy computing process provided by some embodiments. The process includes the following steps:

[0123] S701: Receive a privacy-preserving computing task execution instruction and identify the algorithm identifier carried in the privacy-preserving computing task execution instruction.

[0124] S702: Obtain the algorithm image corresponding to the above-mentioned algorithm identifier from the image repository. If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, obtain the data to be verified carried by the algorithm image, and compare the data to be verified with the benchmark verification data for the algorithm image provided by other privacy computing platforms. If the comparison result is consistent, run the algorithm image in a containerized manner and perform corresponding privacy computing based on the privacy algorithm in the algorithm image; wherein, the algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

[0125] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to FIG8 , FIG8 shows a schematic diagram of an eighth privacy computing process provided by some embodiments, which includes the following steps:

[0126] S801: Receive a privacy-preserving computing task execution instruction and identify the algorithm identifier carried in the privacy-preserving computing task execution instruction.

[0127] S802: Obtain the algorithm image corresponding to the above-mentioned algorithm identifier from the image repository. If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, perform a vulnerability scan on the algorithm image. If the scan result shows a vulnerability without a set security threat level, run the algorithm image in a containerized manner and perform corresponding privacy computing based on the privacy algorithm in the algorithm image. The algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

[0128] Due to the security aspects of the algorithm image (container image) in this application, it can be stipulated that the publisher needs to carry verification information such as the image's signature information when publishing the algorithm image to prevent the algorithm image from being tampered with during the publishing process and storage process. When the user pulls and deploys the algorithm image on a heterogeneous platform, the algorithm image can be verified (checked) and scanned for vulnerabilities, etc., to ensure the security and availability of the algorithm image.

[0129] Example 4:

[0130] In order to enable users to understand the algorithm parameter information of the privacy algorithm used for privacy computing, based on the above embodiments, in the embodiment of the present application, the method further includes:

[0131] Identify and display the algorithm parameter information carried by the algorithm image.

[0132] In one possible implementation, in order to standardize algorithm image generation standards, in addition to standardizing algorithm image definitions, algorithm component name definitions may also be standardized. For example, the algorithm component name definition specifications may include component (algorithm component) name specifications and component instance state specifications.

[0133] Among them, (a) the component name naming specification can be as follows:

[0134] Optionally, the component name can be used to uniquely identify the name string of the component, and the component name can be named in the form of <prefix>.<version>.<type>.<name>. Exemplarily, the component name can be: intercom.v1.algorithm.hetero_lr, etc. Among them, the <prefix> in the component name can be a prefix specified in the interoperability standard, such as intercom, etc., which can be flexibly set according to needs, and this application does not make specific restrictions on this. The <version> in the component name can be the corresponding interface version, such as v1, etc. The <type> in the component name can be a component type (algorithm type), such as algorithm type such as algorithm, and this application does not make specific restrictions on this. The <name> in the component name can be the name identifier of an algorithm component (corresponding interface) such as the linear regression algorithm (LR), such as hetero_lr, etc.

[0135] Among them, (b) the component instance state specification can be as follows:

[0136] Table 10 shows a schematic diagram of a component instance state specification provided by some embodiments, and Figure 9 shows a schematic diagram of a component instance state provided by some embodiments. Referring to Table 10 and Figure 9, when a component image is not loaded into the system, the initial state of the component instance of the component image may be "not loaded". The relevant content regarding the creation of a component instance of a component image will be introduced in subsequent embodiments and will not be repeated here. When the component image has completed downloading and verification and is loaded into the system, the state of the component instance may be "loaded", at which point the component image can be started or uninstalled. When the component image starts running, the state of the component instance may be "running" (or "started"). When the component image stops running, the state of the component instance may be "stopped", at which point the component image can be restarted or uninstalled. If a fault occurs after the component image is started, the state of the component instance may be "failed".

[0137] Table 10

[0138] In one possible implementation, before running the algorithm image in a containerized manner, a component instance of the algorithm image can be created and a service registration can be performed on the component instance, so that the algorithm services provided by the algorithm image can be discovered and called, and then subsequent steps can be performed in a containerized manner to run the algorithm image corresponding to the algorithm identifier obtained from the image repository with a pre-established connection.

[0139] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to Figure 10, Figure 10 shows a ninth privacy computing process provided by some embodiments, which includes the following steps:

[0140] S1001: A container manager in an electronic device queries algorithm image information from an image repository to obtain several algorithm images.

[0141] S1002: When the scheduling service in the electronic device receives a privacy-preserving computing task execution instruction, it identifies the algorithm identifier carried in the privacy-preserving computing task execution instruction and can submit the privacy-preserving computing task execution instruction to the container manager.

[0142] S1003: The container manager identifies the algorithm identifier carried in the privacy computing task running instruction. If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, it can send an instance creation request to the component instance service (algorithm instance service) to create a component instance (also called an algorithm instance) of the privacy algorithm corresponding to the algorithm identifier.

[0143] S1004: The component instance service creates a component instance of the privacy algorithm corresponding to the algorithm identifier, initializes the component instance, and loads it into the system.

[0144] S1005: The component instance service submits an application for service registration of the component instance to a component registration and discovery service in the electronic device.

[0145] S1006: The component registration and discovery service registers the component instance so that the algorithm services provided by the corresponding algorithm image can be discovered and called.

[0146] S1007: The container manager may periodically send an instruction to the component instance service to perform instance health check.

[0147] S1008: The component instance service may perform a health check on the component instance and may feed back the health check result to the container manager.

[0148] S1009: If the health check result is passed, the component instance service reports the status information that the privacy computing task can start running to the scheduling service.

[0149] Among them, the health check of the component instance can be to compare the signature to-be-verified information of the algorithm image with the benchmark verification data, perform vulnerability scanning, etc. If the comparison result is that the information to be verified is consistent with the benchmark verification data, and the vulnerability scan result is that there are no vulnerabilities with the set security threat level, then the health check result can be considered to have passed; otherwise, the health check result can be considered to have failed.

[0150] S1010: The scheduling service runs the algorithm image identified by the algorithm in a containerized manner and performs corresponding privacy-preserving computations based on the privacy-preserving algorithm in the algorithm image. The scheduling service feeds the privacy-preserving computation results back to the container manager.

[0151] S1011: When the privacy computing task is completed, the container manager can send an instance destruction instruction to the component instance service.

[0152] S1012: The component instance service may clean up the component instance and send a request for service deregistration of the component instance to the component registration and discovery service.

[0153] S1013: The component registration and discovery service deregisters the component instance and feeds back the deregistration information to the component instance service.

[0154] In one possible implementation, the algorithm image self-description information can be standardized. The algorithm component image self-description information primarily refers to defining the basic information of the algorithm image in the image label information (LABELS) when creating a container image (algorithm image). This allows heterogeneous privacy computing platforms to use the algorithm image for privacy computing by preloading, identifying (dynamically generating) the algorithm information carried in the algorithm image label information, and displaying this algorithm information.

[0155] Optionally, the algorithm image self-description information may mainly include four types of algorithm information: algorithm function self-description information, algorithm parameter self-description information, algorithm input self-description information, and algorithm output self-description information. Referring to Table 11, Table 11 shows a schematic table of algorithm function self-description information provided in some embodiments. The algorithm function self-description information may include the version number followed by the privacy algorithm, the algorithm component name, the algorithm component description, the algorithm component version, the version of the nth sub-algorithm in the algorithm component, the name of the nth sub-algorithm in the algorithm component, the description information of the nth sub-algorithm in the algorithm component, and a list of roles implemented by the algorithm component (sub-algorithm) in privacy computing. The list of roles implemented in privacy computing may include guest, host, arbiter, etc., where guest represents the data application party and host represents the data provider party. In vertical algorithms, the guest is often the party with label y. The arbiter can be used to assist multiple parties in completing joint modeling. Its main function is to aggregate gradients or models, which will not be described in detail here.

[0156] Table 11

[0157] See Table 12, which shows a schematic table of algorithm parameter self-description information provided by some embodiments. Optionally, the algorithm parameter self-description information may include: the name of the nth parameter, the description of the nth parameter, the type of the nth parameter, etc. The parameter type may include integer, string, float, Boolean, etc.

[0158] Table 12

[0159] See Table 13, which shows a schematic table of algorithm input self-description information provided by some embodiments. Optionally, the algorithm input self-description information may include: the name of the nth input, the description of the nth input, the type of the nth input, etc. The input type may include model (model), dataset (dataset), training set (training_set), test set (testing_set), report (report), etc.

[0160] Table 13

[0161] See Table 14, which shows a schematic table of algorithm output self-descriptive information provided by some embodiments. Optionally, the algorithm output self-descriptive information may include: the name of the nth output, the description of the nth output, the type of the nth output, etc. Output types may include model (model), dataset (dataset), training set (training_set), test set (testing_set), report (report), etc., which will not be repeated here.

[0162] Table 14

[0163] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to FIG11 , FIG11 shows a schematic diagram of a tenth privacy computing process provided by some embodiments. The process includes the following steps:

[0164] S1101: Receive a privacy-preserving computing task execution instruction and identify the algorithm identifier carried in the privacy-preserving computing task execution instruction.

[0165] S1102: Obtain the algorithm image corresponding to the above-mentioned algorithm identifier from the image repository. If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, perform a vulnerability scan on the algorithm image. If the scan result shows a vulnerability without a set security threat level, run the algorithm image in a containerized manner and perform corresponding privacy computing based on the privacy algorithm in the algorithm image. The algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

[0166] S1103: Identify the algorithm information carried by the algorithm image and display the corresponding algorithm information.

[0167] For ease of understanding, the privacy computing process provided by this application is further explained below through a specific embodiment. Referring to Figure 12, Figure 12 shows a schematic diagram of the eleventh privacy computing process provided by some embodiments, which includes the following steps:

[0168] The container manager in the electronic device queries the algorithm image information from the image repository and pulls several algorithm images to the local electronic device. When the scheduling service in the electronic device receives the privacy computing task execution instruction, it identifies the algorithm identifier carried in the privacy computing task execution instruction and can submit the privacy computing task execution instruction to the container manager. The container manager identifies the algorithm identifier carried in the privacy computing task execution instruction. If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, it can create a component instance (algorithm instance) of the privacy algorithm corresponding to the algorithm identifier through the application program interface service (API server). Optionally, the container manager can perform lifecycle management of the component instance creation process, cancellation process, etc. through the API server, etc., which will not be repeated here.

[0169] The component instance service (algorithmminstance service) can submit a service registration application (register query) for the above-mentioned component instance to the component registration and discovery service (component register and discovery service) in the electronic device. The component registration and discovery service registers the component instance so that the algorithm services provided by the corresponding algorithm image can be discovered and called. The component instance service reports the status information that the privacy computing task can start running to the scheduling service (schedule service). The scheduling service (schedule service) runs the algorithm image identified by the above-mentioned algorithm in a containerized manner, and performs corresponding privacy computing based on the privacy algorithm in the algorithm image. The scheduling service (schedule service) submits the privacy computing results to the container manager (container manager).

[0170] Optionally, after the privacy computing task is completed, the container manager can send an instance destruction instruction to the component instance service (not shown). The component instance service can deregister and clean up the component instance and send an unregister query to the component registration and discovery service. The component registration and discovery service deregisters the component instance.

[0171] The component registration and discovery service can be used to manage component instances, providing registration and lookup services for algorithm components. The scheduling service can be used to schedule privacy-preserving algorithm jobs and privacy-preserving computing tasks. The container manager can encapsulate the orchestration capabilities of underlying containers (such as the Kubernetes Infra container) and receive information sent by the scheduling service. The container manager can block specific container engines, such as whether the specific container engine is an application container engine (Docker) or a pod manager (Podman). The container manager can also block specific container orchestrations, such as whether the container orchestration is Kubernetes (Kubernetes) or OpenShift. Furthermore, the container manager can block specific image repositories, such as whether the image repository connected to the electronic device is a public or private repository. The terms component registration and discovery service, scheduling service, container manager, and component instance service are merely logical abstractions and do not correspond to specific services, nor do they specify their physical form.

[0172] For ease of understanding, the privacy computing process provided by this application is explained below through a specific embodiment. Referring to Figure 13, Figure 13 shows a schematic diagram of the relationship between a privacy computing task and a component instance provided by some embodiments.

[0173] Through a loading mechanism, an algorithm image (component image) can be loaded into a component instance and registered with the registration and discovery service for invocation by multiple privacy-preserving computing tasks. Optionally, the relationship between privacy-preserving computing tasks and component instances can be many-to-one or one-to-one. For example, multiple privacy-preserving computing tasks can correspond to one component instance, such as privacy-preserving computing task 1, privacy-preserving computing task 2, and privacy-preserving computing task 3, all of which can use the same component instance. Alternatively, one privacy-preserving computing task can correspond to one component instance, which is not specifically limited in this application.

[0174] Optionally, each privacy computing platform can implement container loading capabilities through a container manager based on its own infrastructure. Taking k8s as an example, after the container manager builds the Deployment configuration, it can call the API server's REST interface or the command line tool (kubectl) command to create a pod that encapsulates the container, that is, a component instance. Among them, the component image (algorithm image) can refer to a packaged container image file used to represent the algorithm component. A component instance can refer to a process or service used to provide component functionality after the component instance is loaded and started. The component instance can run in a resident form or a one-time form.

[0175] Optionally, running in a resident form may mean that after the algorithm component is loaded, the component instance formed will persist in the system for use by one or more tasks (privacy computing tasks). The algorithm component can be started by loading and starting the algorithm component when it is used for the first time, or by pulling it up and starting it when the system starts. The algorithm component can be stopped when the system stops, or according to the system idle status. Running in a single form may mean that the algorithm component starts when the task starts and stops when the task is completed. Optionally, regardless of the form of operation, the workflow and steps of the algorithm component are the same.

[0176] The following further describes the standard algorithm component loading management mechanism, which can be composed of two parts: component management service and component support service. The entire lifecycle of the standard algorithm component can be managed by the container manager. For ease of understanding, the privacy computing process provided by this application is explained below using a specific embodiment. See Figure 14, which shows a schematic diagram of the container loading process provided by some embodiments.

[0177] Optionally, the Component Management Service can manage algorithm components and component instances based on component registration and discovery services, network services, data services, computing services, and scheduling services. It is also responsible for managing the containers in which the algorithm components run. For example, it can connect to container platforms (such as Docker, Swarm, and Kubernetes) to complete container orchestration management.

[0178] The Component Support Service can be used to provide basic operating capabilities to the algorithm component, and to provide standard service interfaces for the functions used in the component container, such as the registration and discovery interface. It will map the basic interface functions to the container through Unix file formats or sockets, receive and respond to requests provided by the algorithm component, and can load and start the component container (target container) to run the corresponding algorithm image in a containerized manner, implement the logical process of the privacy algorithm component, and perform privacy calculations based on the privacy algorithm.

[0179] This application innovatively designs component containers (algorithm component containers), the algorithm image loading process, and specifies specifications for defining image names and corresponding algorithm component names. This ensures the uniqueness of algorithm images during the release process, avoiding conflicts and difficulty distinguishing between algorithm images when different heterogeneous platforms subsequently release them. This application also further specifies the methods and formats for algorithm component containers to submit computing tasks and pass algorithm parameters, allowing privacy computing platforms to use the privacy algorithms (heterogeneous algorithm components) of other privacy computing platforms and interact normally with heterogeneous privacy algorithm components.

[0180] In addition, this application provides a general, standardized technical solution for containerizing, submitting, managing, and obtaining the results of privacy-preserving computing tasks using algorithm components. Any privacy-preserving computing platform, once modified and adapted according to this solution, can utilize the algorithm component containers (algorithm images) contributed by other heterogeneous platforms and apply them to its own platform (privacy computing), thereby increasing the diversity of privacy-preserving algorithms and enabling interoperability between them.

[0181] Example 5:

[0182] Based on the same technical concept, the present application provides a privacy-preserving computing device, see Figure 15 . Figure 15 shows a schematic diagram of a privacy-preserving computing device provided by some embodiments, the device comprising:

[0183] Receiving module 1501, configured to receive a privacy-preserving computing task execution instruction and identify an algorithm identifier carried in the privacy-preserving computing task execution instruction;

[0184] The running module 1502 is used to run the algorithm image of the algorithm identifier obtained from a pre-established image repository in a containerized manner if it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, and perform corresponding privacy computing based on the privacy algorithm in the algorithm image; wherein the algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

[0185] In a possible implementation, the operation module 1502 is specifically configured to:

[0186] Identify the algorithm image running standard indicated by the algorithm image generation standard; and run the algorithm image in a containerized manner according to the algorithm image running standard.

[0187] In a possible implementation, the operation module 1502 is specifically configured to:

[0188] According to the container configuration information required by the algorithm image running standard, the operating environment of the target container is configured, the target container is started, and the algorithm image is run.

[0189] In a possible implementation, the operation module 1502 is further configured to:

[0190] Identify a container communication mode carried in the tag information of the algorithm image, and obtain the target container based on the container communication mode.

[0191] In a possible implementation, the operation module 1502 is further configured to:

[0192] Identify log address information carried by the algorithm image; and store the operation log generated by running the algorithm image according to the log address information.

[0193] In a possible implementation, the operation module 1502 is further configured to:

[0194] Identify the algorithm information carried by the algorithm image and display it.

[0195] In a possible implementation, the operation module 1502 is further configured to:

[0196] Obtain the data to be verified carried by the algorithm image, and compare the data to be verified with the benchmark verification data for the algorithm image provided by the other privacy computing platform. If the comparison result is that the two are consistent, then proceed to the subsequent step of running the algorithm image corresponding to the algorithm identifier obtained from the image repository with a pre-established connection in a containerized manner.

[0197] In a possible implementation, the operation module 1502 is further configured to:

[0198] The algorithm image is scanned for vulnerabilities. If the scan result shows that there are no vulnerabilities with a set security threat level, a subsequent step of running the algorithm image corresponding to the algorithm identifier obtained from a pre-established image repository in a containerized manner is performed.

[0199] Based on the same technical concept, the present application also provides an electronic device. Referring to FIG16 , FIG16 shows a schematic diagram of an electronic device provided by some embodiments. The electronic device includes: a processor 1601, a communication interface 1602, a memory 1603, and a communication bus 1604. The processor 1601, the communication interface 1602, and the memory 1603 communicate with each other via the communication bus 1604.

[0200] The memory 1603 stores a computer program. When the program is executed by the processor 1601, the processor 1601 performs the steps of any of the above methods, which will not be repeated here.

[0201] The communication bus mentioned in the electronic device mentioned above may be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus. This communication bus can be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one thick line is used in the figure, but this does not mean that there is only one bus or only one type of bus.

[0202] The communication interface 1602 is used for communication between the electronic device and other devices.

[0203] The memory may include random access memory (RAM) or non-volatile memory (NVM), such as at least one disk memory. Alternatively, the memory may be at least one storage device located away from the processor.

[0204] The above-mentioned processor can be a general-purpose processor, including a central processing unit, a network processor (NP), etc.; it can also be a digital signal processing processor (DSP), an application-specific integrated circuit, a field programmable gate array or other programmable logic device, a discrete gate or transistor logic device, a discrete hardware component, etc.

[0205] Based on the same technical concept, an embodiment of the present application provides a computer-readable storage medium, which stores a computer program that can be executed by an electronic device. When the program runs on the electronic device, the electronic device implements the steps of any of the above methods when executing, which will not be repeated here.

[0206] The above-mentioned computer-readable storage medium can be any available medium or data storage device that can be accessed by the processor in the electronic device, including but not limited to magnetic storage such as floppy disks, hard disks, magnetic tapes, magneto-optical disks (MO), etc., optical storage such as CDs, DVDs, BDs, HVDs, etc., and semiconductor storage such as ROMs, EPROMs, EEPROMs, non-volatile memories (NAND FLASH), solid-state drives (SSDs), etc.

[0207] Based on the same technical concept, the present application provides a computer program product, which includes: computer program code, which, when executed on a computer, enables the computer to implement the method described in any of the above method embodiments applied to an electronic device.

[0208] The above embodiments may be implemented in whole or in part through software, hardware, firmware, or any combination thereof, and may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions that, when loaded and executed on a computer, fully or partially generate the processes or functions described in the embodiments of the present application.

[0209] Those skilled in the art will appreciate that the embodiments of the present application can be provided as methods, systems, or computer program products. Therefore, the present application can adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment in combination with software and hardware. Moreover, the present application can adopt the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) that contain computer-usable program code.

[0210] The present application is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the present application. It should be understood that each flow and / or box in the flow chart and / or block diagram, as well as the combination of the flow chart and / or box in the flow chart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device produce a device for implementing the functions specified in one or more flow charts and / or one or more boxes in the block diagram.

[0211] These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce a product including an instruction device that implements the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0212] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, so that the instructions executed on the computer or other programmable device provide steps for implementing the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0213] Obviously, those skilled in the art may make various changes and modifications to this application without departing from the spirit and scope of this application. Thus, if these modifications and variations of this application fall within the scope of the claims of this application and their equivalents, this application is intended to include these modifications and variations.< / tag> < / image-name> < / developer>

Claims

1. A privacy computing method, the method comprising: Receive a privacy-preserving computing task execution instruction, and identify an algorithm identifier carried in the privacy-preserving computing task execution instruction; If it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, the algorithm image of the algorithm identifier obtained from an image repository with a pre-established connection is run in a containerized manner, and corresponding privacy computing is performed based on the privacy algorithm in the algorithm image; wherein the algorithm image is generated based on the privacy algorithm and the set algorithm image generation standard.

2. The method according to claim 1, wherein: The method of running the algorithm image corresponding to the algorithm identifier obtained from the image repository with which the connection is established in advance in a containerized manner includes: Identifying the algorithm image operation standard indicated by the algorithm image generation standard; According to the algorithm image running standard, the algorithm image is run in a containerized manner.

3. The method according to claim 2, wherein: The step of running the algorithm image in a containerized manner according to the algorithm image running standard includes: According to the required configuration information of the container carried in the algorithm image running standard, the running environment of the target container is configured, the target container is started, and the algorithm image is run.

4. According to the method of claim 3, after identifying the algorithm identifier carried in the privacy computing task running instruction, and before configuring the target container's running environment according to the container's required configuration information carried in the algorithm image running standard, the method further comprises: A container communication mode carried in the tag information of the algorithm image is identified, and the target container is obtained based on the container communication mode.

5. The method according to any one of claims 1 to 4, further comprising: Identify the log address information carried by the algorithm image; According to the log address information, the operation log generated by running the algorithm image is stored.

6. The method according to any one of claims 1 to 4, further comprising: Identify the algorithm information carried by the algorithm image and display it.

7. According to the method according to any one of claims 1 to 4, after identifying that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, and before running the algorithm image corresponding to the algorithm identifier obtained from the image repository with a pre-established connection in a containerized manner, the method further includes: Obtain the data to be verified carried by the algorithm image, and compare the data to be verified with the benchmark verification data for the algorithm image provided by the other privacy computing platform. If the comparison result is that the two are consistent, perform subsequent steps of running the algorithm image corresponding to the algorithm identifier obtained from the image repository with a pre-established connection in a containerized manner.

8. According to the method according to any one of claims 1 to 4, after identifying that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, and before running the algorithm image corresponding to the algorithm identifier obtained from the image repository with a pre-established connection in a containerized manner, the method further comprises: The algorithm image is scanned for vulnerabilities. If the scan result shows that there is no vulnerability with a set security threat level, a subsequent step of running the algorithm image corresponding to the algorithm identifier obtained from an image repository with a pre-established connection in a containerized manner is performed.

9. A privacy computing device, comprising: A receiving module, used to receive a privacy-preserving computing task execution instruction and identify an algorithm identifier carried in the privacy-preserving computing task execution instruction; An operation module is used to run the algorithm image of the algorithm identifier obtained from an image repository with a pre-established connection in a containerized manner if it is identified that the privacy algorithm corresponding to the algorithm identifier is a privacy algorithm designed based on other privacy computing platforms, and perform corresponding privacy computing based on the privacy algorithm in the algorithm image; wherein the algorithm image is generated based on the privacy algorithm and a set algorithm image generation standard.

10. The device according to claim 9, wherein: The running module is specifically used to: identify the algorithm image running standard indicated by the algorithm image generation standard; and run the algorithm image in a containerized manner according to the algorithm image running standard.

11. The device according to claim 10, wherein: The operation module is specifically used to configure the operating environment of the target container according to the container configuration information required by the algorithm image operation standard, start the target container, and run the algorithm image.

12. According to the device according to any one of claims 9-11, the running module is also used to: obtain the data to be verified carried by the algorithm image, compare the data to be verified with the benchmark verification data for the algorithm image provided by the other privacy computing platform, and if the comparison result is that the two are consistent, then perform the subsequent step of running the algorithm image corresponding to the algorithm identifier obtained from the image repository with a pre-established connection in a containerized manner.

13. According to the device according to any one of claims 9-11, the running module is also used to: perform a vulnerability scan on the algorithm image, and if the scan result is a vulnerability without a set security threat level, then perform a subsequent step of running the algorithm image corresponding to the algorithm identifier obtained from an image repository with a pre-established connection in a containerized manner.

14. An electronic device comprising a processor and a memory, wherein: The memory stores program code, and when the program code is executed by the processor, the processor executes the steps of the privacy computing method according to any one of claims 1 to 8.

15. A computer-readable storage medium comprising a program code. When the storage medium is run on an electronic device, the program code is used to enable the electronic device to execute the steps of the privacy computing method according to any one of claims 1 to 8.

Images