Fuzzy AI model training method for data processing accelerator
By using model fuzzy algorithm to fuzzle the AI model in the data processing accelerator, the problem of easy leakage in data transmission of AI models is solved, and the effect of improving data transmission security without hardware encryption is achieved.
Patent Information
- Application Number
- CN202011546765.7
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2020-05-07
- Filing Date
- 2020-12-24
- Publication Date
- 2024-11-08
- Estimated Expiration
- 2040-12-24
Smart Images

Figure CN113627586B_ABST
Abstract
Description
Technical Field
[0001] Embodiments of the present invention generally relate to fuzzy multi-party computation. More specifically, embodiments of the present invention relate to systems and methods for fuzzy AI model training for data processing (DP) accelerators. Background Art
[0002] Sensitive transactions are increasingly being performed by data processing (DP) accelerators, such as artificial intelligence (AI) accelerators or co-processors. This raises the need to protect the communication channel between the DP accelerator and the host system's environment to protect the communication channel from data snooping attacks.
[0003] For example, data transmission for AI training data, models, and inference outputs may not be protected and may leak to untrusted parties through communication channels. In addition, key-based schemes for encrypting data over communication channels may be slow and may not be practical. In addition, most key-based schemes require hardware-based cryptographic engines. Thus, a system is needed for obfuscating data transmission in model training using DP accelerators with or without encryption. Summary of the invention
[0004] According to one aspect of the present application, a method for fuzzifying an artificial intelligence (AI) model is provided. The method may include: receiving an AI model training request from a host through a data processing (DP) accelerator, wherein the AI model training request includes one or more model fuzzy kernel algorithms, one or more AI models and / or training input data; in response to receiving the AI model training request, training one or more AI models based on the training input data through the DP accelerator; in response to the completion of the training, using one or more model fuzzy kernel algorithms, fuzzifying one or more trained AI models; and sending the blurred one or more trained AI models to the host through the DP accelerator.
[0005] According to another aspect of the present application, a computer program product is provided, comprising a computer program, wherein the computer program implements the above method when executed by a processor.
[0006] According to another aspect of the present application, a data processing (DP) accelerator is provided. The data processing (DP) accelerator may include: an interface for receiving an AI model training request from a host, wherein the AI model training request includes one or more model fuzzy kernel algorithms, one or more AI models, and training input data; a training unit, which, in response to receiving the AI model training request, trains one or more AI models based on the training input data; and a fuzzification unit, which is used to fuzzify one or more trained AI models using one or more model fuzzy kernel algorithms, and send the fuzzified one or more trained AI models to the host.
[0007] According to another aspect of the present application, a method for defuzzifying an artificial intelligence (AI) model is provided. The method may include: generating one or more model fuzzy kernel algorithms to fuzzify one or more AI models; generating a training request for performing AI training through a data processing (DP) accelerator, wherein the training request includes training input data, one or more model fuzzy kernel algorithms and one or more AI models; sending the training request to the DP accelerator; in response to the sending, receiving one or more fuzzy AI models from the DP accelerator; and using one or more model defuzzification kernel algorithms corresponding to the one or more model fuzzy kernel algorithms to defuzzify the one or more fuzzy AI models to restore the one or more AI models.
[0008] According to another aspect of the present application, a computer program product is provided, comprising a computer program, wherein the computer program implements the above method when executed by a processor. BRIEF DESCRIPTION OF THE DRAWINGS
[0009] Embodiments of the invention are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings in which like references indicate similar elements.
[0010] Figure 1 is a block diagram illustrating an example of a system configuration for obfuscating communications between a host and a data processing (DP) accelerator according to some implementations.
[0011] Figure 2 is a block diagram illustrating an example of a multi-layer protection scheme for obfuscating communications between a host and a data processing (DP) accelerator according to one embodiment.
[0012] Figure 3 is a block diagram illustrating an example of a host communicating with a DP accelerator according to one embodiment.
[0013] Figure 4 is a flow chart illustrating an example of a communication channel between an obfuscated host and a DP accelerator according to one embodiment.
[0014] Figure 5 is a flow chart illustrating an example of a method for obfuscating a communication channel according to one embodiment.
[0015] Figure 6 is a flowchart illustrating an example of a method of requesting AI training according to one embodiment. DETAILED DESCRIPTION
[0016] Various embodiments and aspects of the present disclosure will be described with reference to the details discussed below, and the accompanying drawings will illustrate various embodiments. The following description and the accompanying drawings are examples of the present disclosure and should not be construed as limiting the present disclosure. Many specific details are described herein to provide a thorough understanding of various embodiments of the present disclosure. However, in some cases, in order to provide a concise discussion of embodiments of the present disclosure, known or conventional details are not described.
[0017] Reference to "one embodiment" or "an embodiment" in the specification means that a particular feature, structure or characteristic described in conjunction with the embodiment may be included in at least one embodiment of the present disclosure. The expression "in one embodiment" appearing in various places in the specification does not necessarily refer to the same embodiment.
[0018] According to a first aspect of the present invention, a host communicates with a data processing (DP) accelerator to request AI (or machine learning (ML)) training through the DP accelerator. The DP accelerator (or system) receives an AI (or ML) model training request from the host, wherein the AI model training request includes one or more model fuzzy kernel algorithms, one or more AI (or ML) models to be trained, and / or training input data. In response to receiving the AI model training request, the system trains one or more AI models based on the training input data. In some embodiments, the AI accelerator already has a copy of the AI model. After training the AI model, the system uses one or more model fuzzy kernel algorithms to fuzzify one or more trained AI models. The system sends the blurred one or more trained AI models to the host.
[0019] According to a second aspect of the present disclosure, a system (e.g., a host or an application of the host) generates one or more model fuzzy kernel algorithms to fuzzify one or more AI models. The system generates a training request to perform AI training by a data processing (DP) accelerator, wherein the training request includes training input data, one or more model fuzzy kernel algorithms, and / or one or more AI models. The system sends the training request to the DP accelerator. In response to the sending, the system receives one or more fuzzy AI models from the DP accelerator. The system uses one or more model defuzzification kernel algorithms corresponding to the one or more model fuzzy kernel algorithms to defuzzify one or more fuzzy AI models, thereby restoring one or more AI models.
[0020] Figure 1 is a block diagram illustrating an example of a system configuration for obfuscating communications between a host and a data processing (DP) accelerator according to some embodiments. Figure 1, the system configuration 100 includes, but is not limited to, one or more client devices 101-102 communicatively coupled to a DP server 104 via a network 103. The client devices 101-102 may be any type of client device, such as a personal computer (e.g., a desktop computer, a laptop computer, and a tablet computer), a "thin" client, a personal digital assistant (PDA), a web-enabled device, a smart watch, or a mobile phone (e.g., a smart phone), etc. Alternatively, the client devices 101-102 may be other servers. The network 103 may be any type of network, such as a local area network (LAN), a wide area network (WAN) such as the Internet, or a wired or wireless combination thereof.
[0021] The server (e.g., host) 104 may be any type of server or server cluster, such as a web server or cloud server, an application server, a backend server, or a combination thereof. The server 104 also includes an interface (not shown) to allow clients such as client devices 101 to 102 to access resources or services provided by the server 104 (such as resources and services provided by the DP accelerator via the server 104). For example, the server 104 may be a cloud server or a server in a data center that provides various cloud services to clients, such as cloud storage, cloud computing services, machine learning training services, data mining services, etc. The server 104 may be configured as part of a software service (SaaS) or platform service (PaaS) system on a cloud, which may be a private cloud, a public cloud, or a hybrid cloud. The interface may include a web interface, an application programming interface (API), and / or a command line interface (CLI).
[0022] For example, a client, in this example a user application (e.g., a web browser, an application) of client device 101, may send or transmit instructions for execution (e.g., artificial intelligence (AI) training, reasoning instructions, etc.) to server 104, and the instructions are received by server 104 via an interface over network 103. In response to the instructions, server 104 communicates with DP accelerators 105 to 107 to complete the execution of the instructions. In some embodiments, the instructions are machine learning type instructions, where the DP accelerator, as a dedicated machine or processor, can execute the instructions many times faster than the execution by server 104. Thus, server 104 can control / manage the execution work of one or more DP accelerators in a distributed manner. Server 104 then returns the execution results to client devices 101 to 102. The DP accelerator or AI accelerator may include one or more dedicated processors, such as the Baidu artificial intelligence (AI) chipset available from Baidu, or alternatively, the DP accelerator may be an AI chipset from NVIDIA, Intel, or some other AI chipset provider.
[0023] According to one embodiment, each of the applications accessing any one of the DP accelerators 105 to 107 hosted by the data processing server 104 (also referred to as the host) can verify that the application is provided by a trusted source or vendor. Each of the applications can be launched and executed within an execution environment (EE) that is specifically configured and executed by the central processing unit (CPU) of the host 104. When the application is configured to access any one of the DP accelerators 105 to 107, an obfuscated connection can be established between the host 104 and the corresponding one of the DP accelerators 105 to 107, thereby protecting the data exchanged between the host 104 and the DP accelerator 105 to 107 from attacks such as eavesdropping, malware / intrusion, etc.
[0024] Figure 2 2 is a block diagram illustrating an example of a multi-layer protection scheme for obfuscating communications between a host and a data processing (DP) accelerator according to one embodiment. In one embodiment, system 200 provides a scheme for obfuscating communications between a host and a DP accelerator without hardware modifications to the DP accelerator. Figure 2 , the host or server 104 can be described as a system with one or more layers that are protected from intrusion, such as user applications 203, runtime libraries 205, drivers 209, operating system 211, and hardware 213 (e.g., central processing unit (CPU), and optionally, one or more security modules (e.g., trusted platform module (TPM))). The host 104 is typically a CPU system that can control and manage execution jobs on the host 104 and / or DP accelerators 105 to 107. In order to protect / obfuscate the communication channel between the DP accelerators 105 to 107 and the host 104, different components may be required to protect different layers in the host system that are susceptible to data intrusion or attack. For example, the execution environment (EE) can protect the user application layer and the runtime library layer from data intrusion.
[0025] Reference Figure 2, system 200 includes a host system 104 and DP accelerators 105 to 107 according to some embodiments. The DP accelerator may include a Baidu AI chipset or any other AI chipset that can perform AI intensive computing tasks, such as an NVIDIA graphics processing unit (GPU). In one embodiment, the host system 104 includes hardware having one or more CPUs 213, and the CPU 213 is equipped with a security module (such as a trusted platform module (TPM)) within the host 104. TPM is a dedicated chip on an endpoint device that stores cryptographic keys (e.g., RSA cryptographic keys) dedicated to the host system for hardware authentication. Each TPM chip may include one or more RSA key pairs (e.g., public and private key pairs), referred to as endorsement keys (EKs) or endorsement credentials (ECs), i.e., root keys. The key pairs are kept inside the TPM chip and cannot be accessed by software. Then, before executing key parts of the firmware and software, they can be hashed by the EK or EC to protect the system from unauthorized firmware and software modifications. Thus, the TPM chip on the host can be used as a root of trust for secure boot.
[0026] The TPM chip also fixes the driver 209 and the operating system (OS) 211 in the working kernel space to communicate with the DP accelerator. Here, the driver 209 is provided by the DP accelerator vendor and can be used as a driver for the user application to control one or more communication channels 215 between the host and the DP accelerator. Because the TPM chip and secure boot protect the OS 211 and the driver 209 in its kernel space, the TPM effectively protects the driver 209 and the OS 211 from unauthorized access.
[0027] Since the communication channel 215 for the DP accelerators 105 to 107 can be exclusively occupied by the OS 211 and the driver 209, the communication channel 215 can be protected by a TPM chip. In one embodiment, the communication channel 215 includes a peripheral component interconnect or a peripheral component interconnect express (PCIE) channel. In one embodiment, the communication channel 215 is an obfuscated communication channel.
[0028] In one embodiment, the host 104 may include an execution environment (EE) 201, which may be forcibly protected by a TPM / CPU 213. Alternatively, the EE may be an independent container environment. The EE may ensure that the code and data loaded within the EE are protected in terms of confidentiality and integrity within the EE. An example of an EE may be Intel Software Guard Extensions (SGX), or AMD Secure Encrypted Virtualization (SEV), or any non-secure execution environment. Intel SGX and / or AMD SEV may include a set of central processing unit (CPU) instruction codes that allow user-level code to allocate a dedicated area of the CPU's memory, which is protected from the impact of processes running at a higher privilege level. Here, the EE 201 may protect a user application 203 and a runtime library 205, wherein the user application 203 and the runtime library 205 may be provided by an end user and a DP accelerator supplier, respectively. Here, the runtime library 205 may convert API calls into commands for the execution, configuration and / or control of the DP accelerator. In one embodiment, the runtime library 205 provides a predetermined set of (e.g., predefined) kernel algorithms executed by the user application.
[0029] The host 104 may include a memory security application 207 implemented using a memory security language such as Rust and GoLang. These memory security applications running on a memory secure Linux version such as MesaLock Linux may further protect the system 200 from data confidentiality and integrity attacks. However, the operating system may be any Linux distribution, UNIX, Windows OS, or Mac OS.
[0030] The host 104 can be set up as follows: a memory-safe Linux distribution is installed on a system equipped with a TPM secure boot. The installation can be performed offline during the manufacturing or preparation phase. The installation can also ensure that the user space applications of the host system are programmed using a memory-safe programming language. Ensuring that other applications running on the host system 104 are memory-safe applications can further mitigate potential memory-type attacks on the host system 104.
[0031] Then, after installation, the system can be started through a TPM-based secure boot. TPM secure boot ensures that only signed / certified operating systems and accelerator drivers are started in the kernel space that provides accelerator services. In one embodiment, the operating system can be loaded through a hypervisor. Note that a hypervisor or virtual machine manager is computer software, firmware, or hardware that creates and runs virtual machines. Note that kernel space is a declarative area or scope in which a kernel (i.e., a predetermined (e.g., predefined) set of functions for execution) is identified to provide functions and services to user applications. In the event that the integrity of the system is compromised, TPM secure boot may not be able to start the system, but instead shut down the system.
[0032] After the secure boot, the runtime library 205 runs and creates the EE 201, which places the runtime library 205 in the trusted memory space associated with the CPU 213. Next, the user application 203 is started in the EE 201. In one embodiment, the user application 203 and the runtime library 205 are statically linked and started together. In another embodiment, the runtime library 205 is first started in the EE, and then the user application 203 is dynamically loaded into the EE 201. In another embodiment, the user application 203 is first started in the EE, and then the runtime library 205 is dynamically loaded in the EE 201. Note that the statically linked library is a library that is linked to the application at compile time. Dynamic loading can be performed by a dynamic linker. The dynamic linker loads and links shared libraries to run the user application at runtime. Here, the user application 203 and the runtime library 205 in the EE 201 can be visible to each other at runtime, for example, all processes in the EE 201 are visible to each other. However, external access to the EE can be denied.
[0033] In one embodiment, a user application can only call a kernel (or algorithm) from a set of kernels predetermined by the runtime library 205. In another embodiment, the user application and / or the runtime library may derive or generate additional kernels from the set of kernels. In another embodiment, the user application 203 and the runtime library 205 are hardened with a side-channel-free algorithm to defend against side-channel attacks such as cache-based side-channel attacks. A side-channel attack is any attack based on information obtained from the implementation of a computer system, rather than weaknesses in the implemented algorithm itself (e.g., cryptanalysis and software defects). Examples of side-channel attacks include cache attacks, which are attacks based on the ability of an attacker to monitor the cache of a shared physical system in a virtualized environment or a cloud environment. Hardening may include masking the cache and / or outputs generated by the kernel algorithm to be placed on the cache. Next, when the user application completes execution, the user application terminates its execution and exits from the EE.
[0034] In one embodiment, the EE 201 and / or the memory security application 207 do not need to be implemented, for example, the user application 203 and / or the runtime library 205 are hosted in the operating system environment of the host 104. In one embodiment, the kernel set includes a fuzzy kernel algorithm, which includes a model fuzzy kernel algorithm and / or any other type of fuzzy kernel algorithm. Here, the model fuzzy kernel algorithm may be a dedicated kernel algorithm for fuzzy AI models, and these algorithms may be different from or the same as other types of fuzzy kernel algorithms (e.g., algorithms for fuzzy data other than AI models, such as training input data, reasoning output data, etc.). Fuzzification refers to obscuring the intended meaning of communication by making the communication message difficult to understand, usually using vague and ambiguous language. Fuzzy data is more difficult and complex for reverse engineering. Before transmitting data, a fuzzy algorithm can be applied to obscure (encrypt / decrypt) data communications, thereby reducing the chance of eavesdropping.
[0035] In one embodiment, the fuzzy kernel algorithm may include different types of algorithms, such as left shift, right shift, bit rotation (or circular shift), XOR algorithm, etc., to hide any underlying values of the AI model and / or the text / binary representation of the AI model. In one embodiment, the model fuzzy kernel algorithm may be a randomized or deterministic algorithm. A deterministic algorithm is an algorithm that will always generate the same output given a specific input. A randomized algorithm is an algorithm that uses randomness as part of its logic.
[0036] In one embodiment, the model fuzzy kernel algorithm may be a symmetric or asymmetric algorithm. A symmetric fuzzy algorithm may use the same algorithm to fuzzy data communication and defuzzify data communication. An asymmetric fuzzy algorithm requires a pair of algorithms, where the first algorithm in the pair is used for blurring and the second algorithm in the pair is used for defuzzification. Here, a corresponding model defuzzification kernel algorithm may be generated for each model fuzzy kernel algorithm to restore the fuzzy kernel to restore the AI model. In another embodiment, the asymmetric fuzzy algorithm includes a single fuzzy algorithm for blurring a data set, but the data set is not intended to be defuzzified, for example, there is no corresponding defuzzification algorithm.
[0037] In one embodiment, the obfuscation algorithm may further include an encryption scheme to further encrypt the obfuscated data for an additional layer of protection. Unlike computationally intensive encryption, obfuscation algorithms can simplify computations. Some obfuscation techniques may include, but are not limited to, letter obfuscation, name obfuscation, binary / data obfuscation, control flow obfuscation, and the like. Letter obfuscation is the process of replacing one or more letters in the data with specific replacement letters to render the data meaningless. Examples of letter obfuscation include letter rotation functions, in which each letter is shifted or rotated along a predetermined number of positions in the alphabet. Another example is the reordering or reversing of letters based on a specific pattern. Name obfuscation is the process of replacing a specific target string with a meaningless string. Binary obfuscation obfuscates the values of the AI model in the binary representation of the values of the AI model. Control flow obfuscation can change the order of control flow in a program that has additive code (inserting dead code, inserting uncontrolled jumps, inserting alternative structures) to hide the true control flow of the algorithm / AI model.
[0038] For example, the AI model may be stored as a text-based or binary file format as columns, tables, nested, array-based, and hierarchical values. The fuzzification algorithm may be a circular shift algorithm applied to a circular shift of a data container of the AI model. The data container may be in a single-precision (32-bit) floating point format, a half-precision floating point format, or any other format. The container may store the values of the columns, tables, nested, array-based, hierarchical, and / or binary representation values of the AI model. For example, if the weight / bias value of the AI model is stored as a data container represented by 32 bits of binary, the algorithm may circularly shift the binary bits of the data container by 5 bits to the left to fuzzy the value of the data container. In this way, the weight / bias value of the AI model is blurred.
[0039] In another embodiment, each column, table, nested, array-based, and hierarchical data container of the AI model may have a different fuzzification algorithm applied to it. For example, if the AI model is based on array values, array [0] may be applied to a left-rotating loop, array [1] may be applied to a right-rotating loop algorithm, and so on. In another embodiment, different column, table, nested, array-based, and hierarchical values may be applied to different degrees of algorithms. For example, array [0] may be rotated left by '3', while array [1] may be rotated right by '5'. Here, the type and degree of the algorithm may be stored as metadata of the data container mapping the AI model, as well as which algorithm and to what degree is applied to each data container. In one embodiment, the underlying values of the AI model, such as weights and / or bias values, the number of layers, the type of activation function, the connections to the layers, and / or the ordering of the layers of the AI model may each be fuzzified based on the metadata mapping.
[0040] For example, the nesting or connections of the AI model can be tabulated to show which nodes of the current layer are connected to which nodes in the subsequent layer. These tables representing the AI model node connections can be blurred to blur the node connections of the AI model. Examples of node connection blurring can be: node 1 of layer 1 is connected to node 1 of layer 2, according to the node connection blurring scheme, node 1 of layer 1 can be blurred to connect to node 3 of layer 8, etc. In addition, the weight / bias value of each individual node can be mapped to the type of algorithm used for blurring (e.g., left circular shift) and a certain degree (e.g., 5 bits) of the algorithm. Although some examples are shown, the blurring algorithm should not be interpreted as limiting.
[0041] In summary, system 200 provides multiple layers of protection for DP accelerators (for data transfer including machine learning models, training data, and inference outputs) to prevent loss of data confidentiality and integrity. System 200 may include a TPM-based secure boot protection layer, an EE layer, and a core authentication / verification layer. In addition, system 200 may provide a memory-secure user space by ensuring that other applications on the host are implemented in a memory-secure programming language, which may further eliminate attacks by eliminating potential memory corruption / vulnerabilities. In addition, system 200 may include applications that use side-channel-free algorithms to defend against side-channel attacks (e.g., cache-based side-channel attacks).
[0042] Finally, the runtime library can provide a fuzzy kernel algorithm to fuzzify data communications between the host and the DP accelerator. In one embodiment, fuzzification can be paired with a cryptographic scheme. In another embodiment, fuzzification is the only protection scheme and cryptographic-based hardware becomes unnecessary for the DP accelerator.
[0043] Figure 3 is a block diagram illustrating an example of a host communicating with a DP accelerator according to one embodiment. Here, the obfuscation scheme in the communication does not require cryptographic-based hardware of the host or the DP accelerator. In addition, the obfuscation algorithm can be applied only to the AI model and not to the training data input or inference output. Figure 3 , the system 300 may include the EE 201 of the host 104 in communication with the DP accelerator 105 .
[0044] The EE 201 of the host 104 may include a user application 203, a runtime library 205, and a persistent or non-persistent memory 325. The memory 325 may include storage space for algorithms 321, such as model blurring and / or deblurring kernel algorithms. The DP accelerator 105 may include a persistent or non-persistent memory 305, a training unit or logic 351, and a blurring unit or logic 352. The memory 305 may include storage space for the blurring kernel algorithm 301 and storage space for other data (e.g., AI models, input / output data 303). The user application 203 of the host 104 may establish one or more blurring communication (e.g., blurring and / or encryption) channels 215 with the DP accelerator 105.
[0045] One or more fuzzy communication channels 215 may be established for the DP accelerator 105 to send the trained AI model to the host 104. Here, the host 104 may establish a fuzzy communication channel by generating one or more model fuzzy kernel algorithms (and / or corresponding defuzzification kernel algorithms). In one embodiment, the host 104 may generate metadata that maps the type and degree of fuzzy algorithms to be applied and which parts of the AI model. The host 104 then sends the model fuzzy algorithm to the DP accelerator (e.g., DP accelerator 105).
[0046] In another embodiment, when a communication channel is lost or terminated, the fuzzy algorithm may be reestablished, wherein a derived fuzzy algorithm is generated for the communication channel by the host 104 and / or the DP accelerator 105. In another embodiment, the one or more fuzzy algorithms / one or more schemes used for the channel 215 are different from the one or more fuzzy schemes used for other channels between the host 104 and other DP accelerators (e.g., DP accelerators 106-107). In one embodiment, the host 104 includes a fuzzy interface that stores a fuzzy algorithm for each communication session of the DP accelerators 105 to 107. Although fuzzy communication is shown between the host 104 and the DP accelerator 105, fuzzy communication (e.g., fuzzification) may be applied to other communication channels, such as a communication channel between the clients 101 to 102 and the host 104.
[0047] In one embodiment, the training unit 351 is configured to train the AI model received from the host 104 using the input data set 303. The fuzzification unit 352 is configured to fuzzify the AI model using a model fuzzy kernel algorithm.
[0048] Figure 4 is a flow chart illustrating an example of an ambiguous communication protocol between a host and a DP accelerator according to one embodiment. Figure 4 , the operation 400 of the protocol may be performed by Figure 1 System 100 or Figure 3The system 300 is executed. In one embodiment, a client device, such as a client device (e.g., a client / user) 101, requests training of an AI model. Here, the AI model may be any type of AI model, including but not limited to support vector machines, linear regression, random forests, machine learning neural networks (e.g., deep, convolutional, recursive, long-term memory single-layer perceptrons, etc.), etc. For example, training may be an optimization process for calculating different weights and / or bias values of a neural network for an AI model. The AI model may be trained based on a previously trained AI model (e.g., a pre-trained AI model) or a new AI model. Here, the DP accelerator 105 may generate a new AI model for training.
[0049] In operation 401, the host 104 generates one or more model blur kernel algorithms and / or model deblur kernel algorithms to blur and deblur the AI model. The blur algorithm can be any type of blur algorithm. The algorithm can be symmetric or asymmetric, random or deterministic. In one embodiment, the host 104 generates metadata corresponding to the algorithm of the training session to train the AI model. The metadata may indicate the type of blur algorithm, the degree (or the input value of the blur algorithm), and / or which parts of the AI model to blur.
[0050] In operation 402, the host 104 (representing the client 101 or application resident on the host 104) sends an AI model training request to the DP accelerator 105. The training request is a request for training to be performed by any DP accelerator, which is here the DP accelerator 105. In one embodiment, the training request includes a model fuzzy kernel algorithm, associated metadata, and optional training input data, and / or an AI model (e.g., a new model to be trained or a previously trained model to be retrained).
[0051] In operation 403, in response to receiving the request, the DP accelerator 105 initiates an AI model training session based on the AI model and the training input data, which may be performed by the training unit 351 of the DP accelerator 105. In one embodiment, the DP accelerator 105 generates a new AI model for training.
[0052] At operation 404, after the training is completed, the DP accelerator 105 processes the training data to generate a trained AI model. The DP accelerator 105 uses the model fuzzy kernel algorithm received from the host 104 from operation 402 to fuzzify the trained AI model. The fuzzification process may be performed by the fuzzification unit 352 of the DP accelerator 105. In one embodiment, metadata corresponding to the model fuzzy kernel algorithm may be recovered to determine the degree of fuzzification (e.g., circular shift to the left), to which part of the trained AI model the degree of fuzzification (e.g., shift 5) is applied (e.g., layer 1, node 1).
[0053] In one embodiment, the metadata indicates the storage format of the AI model. In another embodiment, the metadata itself is further obfuscated by a metadata obfuscation algorithm. The metadata obfuscation algorithm may be an algorithm previously agreed upon by the host 104 and by each of the DP accelerators. In one embodiment, the metadata obfuscation algorithm may be a deterministic algorithm. Although the AI model shown in the above example is a neural network, this should not be construed as limiting.
[0054] In one embodiment, the metadata may be JavaScript Object Notation (JSON), xml, or any text-based and / or binary file. For example, the metadata may be a JSON file with node branches for nodes / layers of a specified AI model. In one embodiment, the metadata may include the type of fuzzy algorithm, the degree of name / value pairs for each of the JSON nodes. In this way, the metadata may indicate the algorithm to be applied to the node (here, the node may be, for example, a weight and / or bias value). For example, a node (e.g., a weight and / or bias value for the first node of the first layer) may be applied to a 5-bit circular left shift, while another node of the AI model (e.g., a weight and / or bias value for the second node of the second layer) will be applied to a 3-bit circular right shift. Thus, based on metadata information specifying different types of algorithms (left shift, right shift or other fuzzy algorithms, etc.), the degree of fuzziness (e.g., how many bits are shifted), the model fuzzy kernel algorithm can be applied to part of the AI model.
[0055] In one embodiment, one or more model fuzzy kernel algorithms are time-expiring algorithms that expire after some predetermined time period. For example, the algorithms may expire after a few hours, days, or weeks. If a model fuzzy kernel algorithm expires, a derived model fuzzy kernel algorithm may be generated by the DP accelerator and / or the host to replace the expired algorithm. In one embodiment, the metadata specifies a predetermined time period before one or more model fuzzy kernel algorithms expire. In another embodiment, the metadata specifies instructions to generate a derived model fuzzy kernel algorithm based on the expiration time.
[0056] The instruction may be a deterministic instruction (for a threshold number of derived model blur kernel algorithms) agreed upon by the host 104 and the DP accelerator. In this way, when the algorithm expires, both the host and the DP accelerator may generate derived blur / deblur kernel algorithms and use the derived blur / deblur kernel algorithms to blur / deblur the AI model. For example, when expired, a 3-bit circular right shift may generate a derived algorithm of a 2-bit circular right shift. When expired, the derived 2-bit circular right shift algorithm may generate a second derived algorithm of a 1-bit circular right shift, etc., according to the agreed derivation scheme.
[0057] In operation 405, the DP accelerator 105 sends the blurred AI model to the host 104. In one embodiment, the DP accelerator 105 sends a receipt of a state of a specified request to the host 104. In operation 406, in response to receiving the blurred AI model, the host 104 uses a corresponding defuzzification kernel algorithm to defuzzify the blurred AI model to obtain the AI model. In one embodiment, the blur kernel algorithm is a symmetric algorithm, and the corresponding defuzzification kernel algorithm is the same as the blur kernel algorithm. In another embodiment, the kernel algorithm is an asymmetric algorithm, and the corresponding defuzzification kernel algorithm is different from the blur kernel algorithm. In one embodiment, the DP accelerator 105 sends a receipt of a state of a specified request to the host 104, and the host 104 can determine the corresponding defuzzification kernel algorithm based on the receipt.
[0058] Figure 5 is a flow chart illustrating an example of a method for obfuscating a communication channel according to one embodiment. Process 500 may be performed by processing logic that may include software, hardware, or a combination thereof. For example, process 500 may be performed by a DP accelerator, such as Figure 1 DP accelerator 105. Figure 5 In block 501, processing logic (e.g., a DP accelerator) receives an AI model training request from a host, wherein the AI model training request includes one or more model fuzzy kernel algorithms, one or more AI models, and / or training input data. In block 502, in response to receiving the AI model training request, the processing logic trains one or more AI models based on the training input data. In block 503, in response to the training being completed, the processing logic uses the one or more model fuzzy kernel algorithms to fuzzify one or more trained AI models. In block 504, the processing logic sends the fuzzified one or more trained AI models to the host.
[0059] In one embodiment, one or more model blur kernel algorithms are generated by a host, and wherein the host uses one or more corresponding model deblur kernel algorithms to deblur the blurred one or more AI models to restore the one or more AI models. In one embodiment, the one or more model blur kernel algorithms are received on the same communication channel as the training request.
[0060] In one embodiment, one or more model fuzzy kernel algorithms include a left-shift or right-shift algorithm applied to a bit representation of weights and / or bias values of one or more AI models. In one embodiment, one or more model fuzzy kernel algorithms include a deterministic algorithm or a probabilistic algorithm.
[0061] In one embodiment, one or more model fuzzy kernel algorithms are expiring algorithms that expire after some predetermined time period, wherein if the model fuzzy kernel algorithm expires, the derived model fuzzy kernel algorithm will replace the expiring algorithm. In one embodiment, the training request includes metadata specifying a predetermined time period before the one or more model fuzzy kernel algorithms expire.
[0062] Figure 6 is a flow chart illustrating an example of a method for requesting AI training according to one embodiment. Process 600 may be performed by processing logic that may include software, hardware, or a combination thereof. For example, process 600 may be performed by a host, such as Figure 1 Host 104. Figure 6 , at box 601, processing logic (e.g., a host) generates one or more model fuzzy kernel algorithms to fuzzify one or more AI models. At box 602, processing logic generates a training request to perform AI training through a data processing (DP) accelerator, wherein the training request includes training input data, one or more model fuzzy kernel algorithms, and / or one or more AI models. At box 603, processing logic sends the training request to the DP accelerator. At box 604, in response to the sending, processing logic receives one or more blurred AI models from the DP accelerator. At box 605, processing logic uses one or more model defuzzification kernel algorithms corresponding to the one or more model fuzzy kernel algorithms to defuzzify one or more fuzzy AI models to restore one or more AI models.
[0063] In one embodiment, the DP accelerator uses one or more model fuzzy kernel algorithms to fuzzify the trained one or more AI models. In one embodiment, the one or more model fuzzy kernel algorithms are sent on the same communication channel as the training request.
[0064] In one embodiment, one or more model fuzzy kernel algorithms include a left-shift or right-shift algorithm applied to a bit representation of weights and / or biases of one or more AI models. In one embodiment, the one or more model fuzzy kernel algorithms include a deterministic algorithm or a probabilistic algorithm.
[0065] In one embodiment, one or more model fuzzy kernel algorithms are expiring algorithms that expire after a predetermined period of time. If a model fuzzy kernel algorithm expires, the derived model fuzzy kernel algorithm will replace the expiring algorithm. In one embodiment, the training request includes metadata specifying a predetermined time period before the one or more model fuzzy kernel algorithms expire.
[0066] Note that some or all of the components described above may be implemented in software, hardware, or a combination thereof. For example, such components may be implemented as software installed and stored in a permanent storage device, which may be loaded and executed in a memory by a processor (not shown) to perform the processes or operations described throughout this application. Alternatively, such components may be implemented as executable code programmed or embedded in dedicated hardware such as an integrated circuit (e.g., a dedicated IC or ASIC), a digital signal processor (DSP), or a field programmable gate array (FPGA), which may be accessed from an application via a corresponding driver and / or an operating system. In addition, such components may be implemented as specific hardware logic in a processor or processor core as part of an instruction set accessible to a software component via one or more specific instructions.
[0067] Some portions of the foregoing detailed description have been presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, considered to be a self-consistent sequence of operations leading to a desired result. These operations are those requiring physical manipulations of physical quantities.
[0068] It should be borne in mind, however, that all of these and similar terms are intended to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless otherwise expressly indicated in the above discussion, it should be understood that throughout the specification, discussions utilizing terms, such as those set forth in the appended claims, refer to the actions and processes of a computer system or similar electronic computing device that manipulates data represented as physical (electronic) quantities within the computer system's registers and memories and transforms the data into other data similarly represented as physical quantities within the computer system's memories or registers or other such information storage, transmission, or display devices.
[0069] Embodiments of the present invention also relate to devices for performing the operations herein. Such a computer program is stored in a non-transitory computer-readable medium. A machine-readable medium includes any mechanism for storing information in a form readable by a machine (e.g., a computer). For example, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., computer) readable storage medium (e.g., a read-only memory ("ROM"), a random access memory ("RAM"), a magnetic disk storage medium, an optical storage medium, a flash memory device).
[0070] The processes or methods depicted in the foregoing figures may be performed by processing logic including hardware (e.g., circuits, dedicated logic, etc.), software (e.g., embodied on a non-transitory computer-readable medium), or a combination of both. Although the processes or methods are described above in terms of some sequential operations, it should be understood that some of the operations may be performed in a different order. In addition, some operations may be performed in parallel rather than sequentially.
[0071] Embodiments of the present invention are not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of embodiments of the present invention as described herein.
[0072] In the above description, embodiments of the present invention have been described with reference to specific exemplary embodiments of the present invention. It will be apparent that various modifications may be made to the present invention without departing from the broader spirit and scope of the present invention as set forth in the appended claims. Therefore, this specification and the accompanying drawings should be understood in an illustrative sense rather than a restrictive sense.
Claims
1. A method for fuzzy artificial intelligence (AI) model, the method comprising: Receiving, through a data processing (DP) accelerator, an AI model training request from a host, wherein the AI model training request includes one or more model fuzzy kernel algorithms, one or more AI models, and training input data; In response to receiving the AI model training request, training the one or more AI models based on the training input data by the DP accelerator to generate one or more trained AI models; In response to the training being completed, blurring the one or more trained AI models using the one or more model blur kernel algorithms, wherein each data container of the trained AI model has a different blur algorithm applied; and The blurred one or more trained AI models are sent to the host through the DP accelerator.
2. The method of claim 1, wherein: The one or more model blur kernel algorithms are generated by the host, and wherein the host uses one or more corresponding model deblur kernel algorithms to deblur the blurred one or more trained AI models to restore the one or more trained AI models.
3. The method of claim 1, wherein: The one or more model fuzzy kernel algorithms are received over the same communication channel as the training request.
4. The method of claim 1, wherein: The one or more model fuzzy kernel algorithms include a left-shift algorithm or a right-shift algorithm, and the left-shift algorithm or the right-shift algorithm is applied to a data container of weights and / or bias values of the one or more AI models.
5. The method of claim 1, wherein: The one or more model fuzzy kernel algorithms include deterministic algorithms or probabilistic algorithms.
6. The method of claim 1, wherein: The one or more model fuzzy kernel algorithms are expiring algorithms that expire after some predetermined period of time, wherein, in response to the expiration of the model fuzzy kernel algorithm, the derived model fuzzy kernel algorithm will replace the expired algorithm.
7. The method of claim 6, wherein: The training request includes metadata specifying the predetermined time period before the one or more model fuzzy kernel algorithms expire.
8. A data processing (DP) accelerator, comprising: An interface for receiving an AI model training request from a host, wherein the AI model training request includes one or more model fuzzy kernel algorithms, one or more AI models, and training input data; a training unit, which, in response to receiving the AI model training request, trains the one or more AI models based on the training input data to generate one or more trained AI models; and A fuzzification unit is used to fuzzy the one or more trained AI models using the one or more model fuzzy kernel algorithms, and send the blurred one or more trained AI models to the host, wherein each data container of the trained AI model applies a different fuzzy algorithm.
9. The DP accelerator according to claim 8, wherein: The one or more model blur kernel algorithms are generated by the host, and wherein the host uses one or more corresponding model deblur kernel algorithms to deblur the blurred one or more trained AI models to restore the one or more trained AI models.
10. The DP accelerator according to claim 8, wherein: The one or more model fuzzy kernel algorithms are received over the same communication channel as the training request.
11. The DP accelerator according to claim 8, wherein: The one or more model fuzzy kernel algorithms include a left-shift algorithm or a right-shift algorithm, which is applied to the bit representation of the weights and / or biases of the one or more AI models.
12. The DP accelerator according to claim 8, wherein: The one or more model fuzzy kernel algorithms include deterministic algorithms or probabilistic algorithms.
13. The DP accelerator according to claim 8, wherein: The one or more model fuzzy kernel algorithms are expiring algorithms that expire after some predetermined period of time, wherein in response to the model fuzzy kernel algorithm expiring, the derived model fuzzy kernel algorithm replaces the expiring algorithm.
14. The DP accelerator according to claim 13, wherein: The training request includes metadata specifying the predetermined time period before the one or more model fuzzy kernel algorithms expire.
15. A method for deblurring an artificial intelligence (AI) model, the method comprising: Generate one or more model fuzzy kernel algorithms to fuzzify one or more trained AI models; Generating, by a data processing (DP) accelerator, a training request for performing AI training, wherein the training request includes training input data, the one or more model fuzzy kernel algorithms, and one or more AI models; Sending the training request to the DP accelerator, the training request causing the DP accelerator to train the one or more AI models based on the training input data to generate the one or more trained AI models, and causing the DP accelerator to fuzzify the one or more trained AI models using the one or more model fuzzy kernel algorithms, and applying a different fuzzy algorithm to each data container of the trained AI model; In response to the sending, receiving one or more blurred trained AI models from the DP accelerator; and The one or more blurred trained AI models are deblurred using one or more model deblurring kernel algorithms corresponding to the one or more model blurring kernel algorithms to restore the one or more trained AI models.
16. The method of claim 15, wherein: The one or more model fuzzy kernel algorithms are used by the DP accelerator to fuzzy one or more trained AI models.
17. The method of claim 15, wherein: The one or more model fuzzy kernel algorithms are sent over the same communication channel as the training request.
18. The method of claim 15, wherein: The one or more model fuzzy kernel algorithms include a left-shift algorithm or a right-shift algorithm, which is applied to the bit representation of the weights and / or biases of the one or more AI models.
19. The method of claim 15, wherein: The one or more model fuzzy kernel algorithms include deterministic algorithms or probabilistic algorithms.
20. The method of claim 15, wherein: The one or more model fuzzy kernel algorithms are expiring algorithms that expire after some predetermined period of time, wherein in response to the model fuzzy kernel algorithm expiring, the derived model fuzzy kernel algorithm replaces the expiring algorithm.
21. The method of claim 20, wherein: The training request includes metadata specifying the predetermined time period before the one or more model fuzzy kernel algorithms expire.
22. A computer program product, comprising a computer program, wherein the computer program, when executed by a processor, implements the method according to any one of claims 1 to 7.
23. A computer program product comprising a computer program which, when executed by a processor, implements the method according to any one of claims 15 to 21.
