Patent Description:
Data security and encryption is a branch of computer science that relates to protecting information from disclosure to third parties and allowing only an intended party or parties access to that information. The data may be encrypted using various techniques, such as public/private key cryptography, and may be decrypted by the intended recipient using a shared public key and a private key. Transmission of the data is protected from being decrypted by third parties at least by their lack of possession of the private key.

<CIT> describes that a deep neural network may be trained on the data of one or more entities, also know as Alices. An outside computing entity, also known as a Bob, may assist in these computations, without receiving access to Alices' data. Data privacy may be preserved by employing a "split" neural network. The network may comprise an Alice part and a Bob part. The Alice part may comprise at least three neural layers, and the Bob part may comprise at least two neural layers. When training on data of an Alice, that Alice may input her data into the Alice part, perform forward propagation though the Alice part, and then pass output activations for the final layer of the Alice part to Bob. Bob may then forward propagate through the Bob part. Similarly, backpropagation may proceed backwards through the Bob part, and then through the Alice part of the network.

For a more complete understanding of the present disclosure, reference is now made to the following description taken in conjunction with the accompanying drawings.

Particular aspects of the invention are set out in the appended claims, and the dependent claims set out various optional embodiments.

In various embodiments of the present disclosure, a first party that owns proprietary data permits a second party to realize a benefit from the data without actually having to transfer the data; the first party shares only an encrypted version of the data. In some embodiments, a secure= data processor is disposed between the first and second parties on a computer network; two or more data sources send encrypted versions of their data to the secure data processor, which adds them together and sends the result to the second party. The secure data processor cannot decrypt the data because it lacks the necessary keys, and the second party can decrypt only the sum of the data, not the original data.

In some embodiments, multiple data sources encrypt data using encryption key data received from a first system; a second system does not have access to the encryption key data. The second system receives the encrypted data from the multiple data sources. Because the encryption is additively homomorphic, the second system may create encrypted summation data using the encrypted data. The second system may send the encrypted summation data to the first system, which may then decrypt the encrypted summation data to create unencrypted summation data.

In other embodiments, the data source may include noise with the data. A first system creates and sends encryption key data to multiple data sources. A second system receives data encrypted using the encryption key data from the multiple data sources; the data may include noise data such that, even if decrypted, the original data cannot be discovered. Because the encryption is additively homomorphic, the second system may create encrypted summation data using the encrypted data. The first system separately receives the noise data encrypted using the same technique as the encrypted data. The second system may send the encrypted summation data to the first system, which may then remove the noise data from the encrypted summation data to create unencrypted summation data.

In other embodiments, a neural-network model may be securely trained. Computer instructions corresponding to a neural-network model are received and encrypted using an encryption technique. The model is trained using the training data using, for example, a gradient descent technique, and gradient data encrypted using the encryption technique is received from a data source. If the model performs in accordance with a quality metric, it is sent to a device of a model user.

In still other embodiments, a marketplace may be configured to request building the model and to offer to build the model. A request to train a neural-network model is received, as are a first offer to supply encrypted training data and a second offer to train the model. After determining that the offers satisfy the request, a model provider told to train the model. If they model performs in accordance with a quality metric, it is sent to a model user.

Machine-learning systems, such as those that use neural networks, may be trained using training data and then used to make predictions on out-of-sample (i.e., non-training) data. A power company, for example, may collect data regarding a failure likelihood of a particular component; this data may include, for example, temperature, vibration, and voltage data collected during use of the component. The power company may then annotate this data to indicate times at which the component failed. Using this collected and annotated data, the power company may train a neural network to predict when the component will fail based on the already-known times of failure. Once built, the power company may deploy the model to attempt to receive additional data collected from the component and make failure predictions for currently operating components using this out-of-sample data.

The training data may, however, be insufficient in size and/or quality to train a model that predicts component failures with an acceptable accuracy. The power company may improve their model by training it with additional training data, but this additional training data may not be accessible to the power company. A rival power company, for example, may possess some additional training data, but may be reluctant to provide their proprietary intellectual property to a competitor. In other industries or situations, data owners may further be predisposed to not share their data because the data set is too large to manage or because it is in a different format from other data. In still other industries, data owners may be prohibited to share data, such as medical data, due to state laws and/or regulations. A data owner may further be predisposed to not share data, especially publicly, because any further monetary value in the sharing of the data is lost after sharing the data once.

Embodiments of the present disclosure thus relate to systems and methods for securely processing data, such as the training data described above, collected from one or more data sources. The data sources encrypt their data in accordance with the methods described herein; the data sources may add noise to their data to further protect it. The data sources may send their encrypted, noisy data to a secure data processor, which may add each bit of encrypted, noisy data together to create a sum. Either the secure data processor itself, or another system designed to create a model, receives encrypted noise from the data sources. Using the sum of the encrypted, noisy data and the encrypted noisy data, the secure data processor and/or other system removes the noise to create a sum of the data; this sum may be used to train a model that may be of benefit to the one or more data sources (and/or other users of the model). In some embodiments, the data sources encrypt their data in accordance with a set of domain parameters corresponding to an encryption technique, such as Rivest-Shamir-Adleman (RSA) encryption, Advanced Encryption Standard (AES) encryption, or elliptic-curve encryption; in these embodiments, the data source may send only their encrypted data and may not send the encrypted noise data. A marketplace may be configured to facilitate transactions between the data sources and other systems. The data sources thus may benefit financially, or by use of the trained model, without divulging their training data to any other party.

<FIG> show systems that include a secure data processor <NUM> and a network <NUM>. The network <NUM> may include the Internet and/or any other wide- or local-area network, and may include wired, wireless, and/or cellular network hardware. The secure data processor <NUM> may communicate, via the network <NUM>, with one or more model providers <NUM>, model users <NUM>, and/or data sources <NUM>. The secure data processor <NUM> may transmit, via the network <NUM>, requests to the other systems using one or more application programming interfaces (APIs). Each API may correspond to a particular application. A particular application may, for example, be operated within the secure data processor <NUM> or may be operating using one or more of the other systems.

Referring first to <FIG>, in accordance with the present disclosure, a system 100a includes a secure data processor 120a, a model provider 122a, a model user <NUM>, and one or more data sources <NUM>. The model provider 122a sends (<NUM>), to a first data source, encryption key data. The model provider 122a also sends (<NUM>) to a second data source, the encryption key data. The secure data processor 120a receives (<NUM>), from the first data source, first encrypted input data, the first encrypted input data being encrypted based at least in part on the encryption key data. The secure data processor 120a receives (<NUM>), from the first data source, second encrypted input data, the second encrypted input data being encrypted based at least in part on the encryption key data. The secure data processor 120a generates (<NUM>), encrypted summation data corresponding to a sum of the first encrypted input data and the second encrypted input data, wherein the secure data processor <NUM> is not in possession of the encryption key data. The secure data processor 120a sends (<NUM>), to the other of the model provider 122a, using a secure connection, the encrypted summation data. The model provider 122a generates (<NUM>) summation data by decrypting, based at least in part on the encryption key data, the encrypted sum data.

Referring to <FIG>, in accordance with the present disclosure, a system 100b includes a secure data processor <NUM>, a model provider <NUM>, a model user <NUM>, and one or more data sources <NUM>. The secure data processor 120b and/or model provider 122b receives (<NUM>), from a first data source, first encrypted input data. The secure data processor 120b and/or model provider 122b receives (<NUM>), from the first data source, first encrypted noise data. The secure data processor 120b and/or model provider 122b receives (<NUM>), from a second data source, second encrypted input data. The secure data processor 120b and/or model provider 122b receives (<NUM>), from the second data source, second encrypted noise data. The secure data processor 120b and/or model provider 122b generates (<NUM>) encrypted summation data corresponding to a sum of the first encrypted input data and the second encrypted input data. The secure data processor 120b and/or model provider 122b generates (<NUM>) summation data by decrypting, based at least in part on the first encrypted noise data and the second encrypted noise data, the encrypted sum data.

Referring to <FIG>, in accordance with the present disclosure, a system 100c includes a secure data processor 120c, a model provider 122c, a model user <NUM>, and one or more data sources <NUM>. The secure data processor 120c (and/or other system) receives (<NUM>), from a model provider, computer instructions corresponding to a neural-network model. The secure data processor 120c determines (<NUM>) encrypted computer instructions by encrypting, using an encryption technique, at least a portion of the computer instructions. The secure data processor 120c receives (<NUM>), from a first data source, first encrypted change data corresponding to weights of the model, the first encrypted change data being encrypted using the encryption technique. The secure data processor 120c receives (<NUM>), from a second data source, second encrypted change data, the second encrypted change data being encrypted using the encryption technique. The secure data processor 120c determines (<NUM>) an encrypted summation change data by summing the first encrypted changes data and the second encrypted change data. The secure data processor 120c determines (<NUM>) that a metric associated with the changes satisfies a threshold and determines (<NUM>) decrypted change data.

Referring to <FIG>, in accordance with the present disclosure, a system 100d includes a secure data processor <NUM>, a model provider <NUM>, a model user <NUM>, and one or more data sources <NUM>. The secure data processor 120d (and/or other system) receives (<NUM>), from a model user, a first request to provide a trained neural-network model. The secure data processor 120d receives (<NUM>), from a data source, a first offer to provide first encrypted input data. The secure data processor 120d receives (<NUM>), from a model provider 122d, a second offer to train a first neural-network model. The secure data processor 120d determines (<NUM>) that the first offer and the second offer satisfy the first request. The secure data processor 120d sends (<NUM>), to the model provider 122d, a second request to train a second neural-network model using the first neural-network model and the first encrypted training data. The secure data processor 120d receives (<NUM>), from the model provider 122d, the second neural-network model. The secure data processor 120d determines (<NUM>) that the second neural-network model satisfies a quality metric and, based thereon, sends (<NUM>), to the model user <NUM>, the second neural-network model.

<FIG> and <FIG> illustrate computing environments including a secure data processor <NUM> according to embodiments of the present disclosure. A secure data processor <NUM>, described in greater detail below, may be one or more servers configured to receive encrypted data from one or more data sources <NUM>. A model provider <NUM> may provide and/or train a model, such as a neural-network machine-learning model, configured to process the data from the data sources <NUM>. The secure data processor <NUM> and/or the model provider <NUM> may train the model using the data from the data sources <NUM> by, for example, computing weights of the machine-learning model using, for example, stochastic gradient descent. Once the secure data processor <NUM> and/or model provider <NUM> trains the model the model in accordance with one or more metrics, it may send the trained model and/or associated weights to one or more model users <NUM>. In some embodiments, a model user <NUM> is also a data source <NUM>.

Although the secure data processor <NUM>, the model provider <NUM>, model user <NUM>, and data sources <NUM> are illustrated as separate systems, in some embodiments, one or more of the secure data processor <NUM>, the model provider <NUM>, model user <NUM>, and data sources <NUM> may be the same system. For example, the model provider <NUM> may also be the model user <NUM>. One or more of the data sources <NUM> may be the model user <NUM>. The present disclosure is thus not limited to the example environment illustrated in <FIG>.

<FIG> illustrates a computing environment that includes a blockchain database <NUM>. The blockchain database <NUM> may use blockchain technology, as one of skill in the art will understand, to maintain a public ledger of information, such as data transmitted using the secure data processor <NUM>. The secure data processor may not communicate directly with the blockchain database <NUM>; instead, it may communicate using a blockchain market <NUM> and/or a blockchain agent <NUM>.

The blockchain market <NUM> may include pointers to data in one or more data sources <NUM> and may allow access to that data. The blockchain market <NUM> may further contain information related to one more self-performing contracts (i.e., "smart" contracts) relating to data processes or transmitted by the secure data processor <NUM>. The blockchain agent <NUM>, which may be referred to as an "oracle," may monitor the blockchain database <NUM> for information and/or changes to information therein, and may transmit data relating to those changes to the secure data processor <NUM>.

<FIG> illustrate data transfers using computing environments that include a secure data processor <NUM> according to embodiments of the present disclosure. Referring first to <FIG>, the model provider <NUM> sends a model <NUM> to the secure data processor <NUM>. The model <NUM> may be, as explained herein, a neural-network model. The secure data processor <NUM> may send the model <NUM> to one or more data sources <NUM> and, once the model is trained, to the model user <NUM>.

In <FIG> and <FIG>, in various embodiments, the model provider <NUM> creates and transmits encryption key data including at least one or more keys <NUM>. The creator of the encryption key data corresponds to an entity trusted to learn the sum of, but not the individual values of, data owned by data sources <NUM>. In some embodiments, as described in further detail below, the secure data processor <NUM> is trusted to learn only the encrypted sum of the data owned by the data sources <NUM> and is not trusted to learn the unencrypted sum of the data. The secure data processor <NUM> may then send this encrypted sum to the model provider <NUM>, which may determine the unencrypted sum. In these embodiments, as shown in <FIG>, the model provider <NUM> creates and distributes the encryption key data.

The encryption key data may include a modulus n, an exponent e, and/or an element a (as explained in greater detail below). The model provider <NUM> may determine the modulus n by multiplying two prime numbers p and q. The prime numbers may, in some embodiments, be Sophie Germain prime numbers and may be, for example, approximately <NUM> bits in size, and the modulus n may be approximately <NUM> bits in size. The prime numbers p and q may be defined using the below equations (<NUM>) and (<NUM>). <MAT> <MAT>.

The numbers p' and q' may also be prime numbers. The model provider <NUM> may further compute the public modulus n in accordance with the below equation (<NUM>). The public modulus n may, as explained in greater detail below, be sent to and used by a data source <NUM>.

The model provider <NUM> may further compute a function used to select the exponent e that may further be sent to and used by a data source <NUM>. In some embodiments, this function is a Carmichael's totient function λ(n), which may be determined in accordance with the below equation (<NUM>), in which lcm(x, y) finds the least common multiple of x and y.

Using equations (<NUM>) and (<NUM>), equation (<NUM>) may be expressed as the below equation (<NUM>).

The value of λ(n) may be at least <NUM> bits in size. The public exponent e may then be determined using the below equation (<NUM>), in which gcd(x,y) finds the greatest common denominator of x and y.

The model provider <NUM> may further determine the modular multiplicative inverse d of e in accordance with the below equation (<NUM>), in which mod x computes the modulus of x.

The model provider <NUM> may then select an element a of maximum order in a multiplicative group <MAT>, wherein the maximum order of the multiplicative group <MAT> is 2p'q', in accordance with known methods of finding an element of maximum order. In some embodiments, the model provider <NUM> finds a first generator g<NUM> of <MAT> in which n = p - <NUM>, finds a second generator g<NUM> of <MAT> in which n = q - <NUM>, and then uses Gauss's Algorithm to find the element a such that a = g<NUM>(mod p) and a = g<NUM> (mod q) and such that <NUM> ≤ a ≤ n - <NUM>. The generators may be found by choosing a random element of the multiplicative group <MAT>, computing b in accordance with the below equation (<NUM>), and determining if b is equal to one. If b is equal to one, another random element is chosen and b is again computed. If b is not equal to one, b is selected as the element a.

Gauss's Algorithm may be used to find a in accordance with the below equations (<NUM>), (<NUM>), and (<NUM>).

In the above equation (<NUM>), Ni may be determined in accordance with the below equation (<NUM>).

M may be determined in accordance with the below equation (<NUM>).

The model provider <NUM> may further send the element a to the data sources <NUM>, which may further use the element a to encrypt data as explained in greater detail below. The model provider <NUM> may, however, keep the multiplicative inverse d secret.

The data sources <NUM> may encrypt data in accordance with an encryption function H(m). In some embodiments, the encryption function H(m) is defined using the below equation (<NUM>), in which m is less than the value of the Carmichael's totient function λ(n).

The model provider <NUM> may decrypt data in accordance with a decryption function H-<NUM>(c). In some embodiments, the decryption function H-<NUM>(c) is defined using the below equation (<NUM>), in which loga is the discrete logarithm function over base a. The algorithm function loga may be computed by using, for example, a "baby-step giant-step" algorithm.

In various embodiments, data encrypted using the encryption function H(m) is additively homomorphic such that H(m<NUM> + m<NUM>) may be determined in accordance with the below equations (<NUM>) and (<NUM>). <MAT> <MAT>.

In some embodiments, the above equations (<NUM>) and (<NUM>) may be computed or approximated by multiplying H(m1) and H(m2) in accordance with the below equation (<NUM>).

The secure data processor <NUM> may thus, given two items of encrypted data H(m<NUM>) and H(m<NUM>), determine H(m<NUM> + m<NUM>) without first applying the decryption function H-<NUM>(c). In some embodiments, the value of m is <NUM> bits in size.

Referring to <FIG>, the data sources <NUM> may encrypt data plus noise (vi + ηi) in accordance with a first encryption function H(m), as described above, and may encrypt noise (ηi) in accordance with a second encryption function K(m). In some embodiments, the model provider <NUM> creates the second encryption function K(m) using the above-described process of creating the first encryption function H(m). The second encryption function K(m) may, however, use a different set of keys, including but not limited to a different public key, which it may receive from the model provider <NUM>. The data source <NUM> may encrypt (vi + ηi) using one encryption function (for example, H(m)) and may encrypt (ηi) using a different encryption function (for example, K(m)). A data source <NUM> may determine a value vi that it wishes to make available for training of the model <NUM> without allowing knowledge of the actual value of vi to be possessed by the secure data processor <NUM>, model provider <NUM>, and/or model user <NUM>. The value vi may be <NUM> bits in size.

The data source <NUM> selects the random noise value ηi using, for example, a random noise generator. The noise value ηi may be <NUM> bits in size. Using the above encryption function H(m), each data source <NUM> computes H(vi + ηi) <NUM> and each data source <NUM> computes K(ηi) <NUM> using the second encryption function K(m). Each data source <NUM> may then send H(vi + ηi) <NUM> and K(ηi) <NUM> to the secure data processor <NUM>. The data source <NUM> may thereafter delete the noise value ηi to thereby prevent its re-use with subsequent encryption.

The secure data processor <NUM> may determine that it has received the encrypted data plus noise <NUM> and the encrypted noise <NUM> from the data sources <NUM>. Once the encrypted data plus noise <NUM> and the encrypted noise <NUM> is received, the secure data processor <NUM> computes the sum H(Σvi + Σηi) <NUM> of the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n and the sum K(Σηi) <NUM> of the encrypted noise data K(ηi) 312a, 312b,. As explained above, because the encryption functions H(m) and K(m) are additively homomorphic, the sum H(Σvi + Σηi) <NUM> of the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n and the sum K(Σηi) <NUM> of the encrypted noise data K(ηi) 312a, 312b,. 312n may be determined by multiplying and/or modulo-multiplying each encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n and encrypted noise data K(ηi 312a, 312b,. 312n in accordance with one or more of equations (<NUM>), (<NUM>), and/or (<NUM>). The secure data processor <NUM> may then send the sum H(Σvi + Σηi) <NUM> and the sum K(Σηi) <NUM> to the model provider <NUM>.

The model provider <NUM> may decrypt the sum H(Σvi + Σηi) <NUM> using the decryption function H-<NUM>(c) and may decrypt the sum K(Σηi) <NUM> using the decryption function K-<NUM>(c). The model provider <NUM> may then subtract the sum of the decrypted noise data Σηi from the sum of the values-plus-noise data Σ(vi + ηi) to determine the sum Σvi <NUM> of the values vi.

Referring to <FIG>, in some embodiments, the secure data processor <NUM> may include a first secure data processor 120x and a second secure data processor 120y. The first secure data processor 120x and second secure data processor 120y may be untrusted entities and may thus not be trusted to discover the value of the summed data Σvi. The first secure data processor 120x may receive the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n and send the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n to the model provider <NUM>. The second secure data processor 120y may receive the encrypted noise data H(ηi) 312a, 312b,. 312n and may compute the sum H(Σηi) <NUM> of the encrypted noise data H(ηi) 312a, 312b,. 312n, and may send the sum H(Σηi) <NUM> to the model provider <NUM> The model provider <NUM> may then remove the sum H(Σηi) <NUM> from the sum H(Σvi + Σηi) <NUM> to determine the sum Σvi of the values vi,, as described above.

Referring to <FIG>, and with reference also to <FIG>, in some embodiments, the secure data processor <NUM> may include a first secure data processor 120x and a second secure data processor 120y. As discussed above with reference to <FIG>, each data source may encrypt the values-plus noise data vi + ηi with a first encryption function H(m) to create the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n, and may encrypt the noise data ηi with a second encryption function K(m) to create the encrypted noise data K(ηi) 312a, 312b,. A first secure data processor 120x may sum the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n to create the sum H(Σvi + Σηi) <NUM>, and a second secure data processor 120y may sum the encrypted noise data K(ηi) 312a, 312b,. 312n to create the sum H(Σηi) <NUM>. The model provider <NUM>, as described above, may then remove the sum K(Σηi) <NUM> from the sum H(Σvi + Σηi) <NUM> to determine the sum Σvi of the values vi.

Referring to <FIG>, in some embodiments, the data sources <NUM> send the encrypted noise data H(ηi) <NUM> to the model provider <NUM> because the secure data processor <NUM> is not trusted to learn the sum Σvi <NUM> of the data vi. In these embodiments, the data sources <NUM> compute the values-plus-noise data H(vi + ηi) <NUM>, as described above, and send the values-plus-noise data H(vi + ηi) <NUM> to the secure data processor <NUM>. The data sources <NUM> similarly compute the noise data H(ηi) <NUM>, as described above, but send the noise data H(ηi) <NUM> to the model provider <NUM>, not the secure data processor <NUM>. The secure data processor <NUM> computes the sum H(Σvi + Σηi) of the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. As explained above, because the encryption function H(m) is additively homomorphic, the sum H(Σvi + Σηi) of the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n may be determined by multiplying each encrypted values-plus-noise data H(vi + ηi) 310a, 310b,.

The secure data processor <NUM> may then send the sum H(Σvi + Σηi) <NUM> of the encrypted values-plus-noise data H(vi + ηi) 310a, 310b,. 310n to the model provider <NUM>. The model provider <NUM> may then remove the encrypted noise data H(ηi) 312a, 312b,. 312n from the sum H(Σvi + Σηi) <NUM> to determine the encrypted sum H(Σvi) and, finally, the sum Σvi <NUM>. In some embodiments, the model provider <NUM> may decrypt each encrypted noise data H(ηi) 312a, 312b,. 312n using the decryption function H-<NUM>(c). The model provider <NUM> may then decrypt the sum of the encrypted values-plus-noise data H(vi + ηi) and subtract the decrypted noise data from the sum of the decrypted values-plus-noise data (vi + ηi) to determine the sum (Σvi) of the values vi. In other embodiments, the model provider <NUM> subtracts the encrypted noise data H(ηi) 312a, 312b,. 312n from the sum H(Σvi + Σηi) <NUM> to determine the encrypted sum H(Σvi) <NUM>. The model provider <NUM> may subtract the encrypted noise data H(ηi) 312a, 312b,. 312n individually or may, in some embodiments, add the encrypted noise data H(ηi) 312a, 312b,. 312n together to create summed encrypted noise data H(Σηi) before subtracting it from the encrypted sum H(Σvi + Σηi) <NUM>. The model provider <NUM> may then determine the sum Σvi <NUM> of the data vi using the decryption function H-<NUM>(c).

<FIG> illustrates a system for secure data processing in accordance with the present disclosure. In various embodiments, the system of <FIG> permits processing of integers and fixed-point numbers having sizes greater than <NUM> bits and permits up to <NUM>m data sources <NUM>, where m is between <NUM> and <NUM> and wherein a block size is as large as <NUM> - m. The value m may be, in some embodiments, <NUM>. In various embodiments, a given fixed-point number f may be expressed as an integer ui in accordance with the below equation (<NUM>).

In equation (<NUM>), s is any integer; the equation thus shifts the decimal point of fi to the right or left some number of places. In some embodiments, the decimal point is shifted to the right a number of places necessary to convert the fixed-point f to the integer ui. The secure data processor <NUM>, model provider <NUM>, and data sources <NUM> may all use the same value for s. If s is smaller than the actual number of decimal places of fi, the integer ui may represent a rounded value of fi; if s is larger than the actual number of decimal places of fi, the integer ui may include a number of zeros at its end. The sum of the f values may similarly relate to the sum of the ui values in accordance with the below equation (<NUM>).

Each integer value ui may be expressed as a sum of <NUM>-bit blocks in accordance with the below equation (<NUM>).

Thus, ui may be defined as a set of values < uij >, where uij is the value for each <NUM>-bit block. Each value of uij may be between -<NUM><NUM> and <NUM><NUM>-<NUM>; because each block is <NUM> bits, the sum of all the values of uij may between -<NUM><NUM> and <NUM><NUM>-<NUM>. In addition, because each block is <NUM> bits, there may be up to <NUM><NUM> data sources <NUM>.

Thus the model provider <NUM> may define the value s and transmit the value s to the data sources <NUM>. The model provider <NUM> may similarly define and transmit a block size, such as <NUM> bits, to the secure data processor <NUM>, data sources <NUM>, and/or model user <NUM>. Each data source <NUM> possesses at least one fixed-point value fi, which it converts to the corresponding integer ui in accordance with equation (<NUM>), and may compute ui = < uij > using the value s and the block size, in accordance with equation (<NUM>). The data sources <NUM> may encrypt these values using the encryption function H(m), as described above, and send the encrypted data to the secure data processor <NUM>. The secure data processor <NUM> may compute the sum of all the encrypted data received from the data sources <NUM>, as described above, and send the sum to the model provider <NUM>. The model provider <NUM> may compute the unencrypted sum of all the encrypted data using the decryption function H-<NUM>(c), as described above, and may convert the integer value ui to its corresponding fixed-point value fi using equation (<NUM>).

The data sources <NUM> may determine and use a noise value noise value ηi when sending the data to the secure data processor <NUM>, as described above. In some embodiments, in addition to using the noise value ηi as described above, the data sources determine and use a second noise value pi. For example, in cases in which ui is small and j is large, some values of uij may be zero. If uij is zero, the encrypted value H(uij + ηi) becomes simply H(ηi), and a component of the system not permitted to learn ηi, such as, in some embodiments, the secure data processor <NUM>, could learn noise value ηi simply by decrypting H-<NUM>(uij + ηi).

Thus, in some embodiments, the data source <NUM> adds the second noise value pi to the integer value ui before processing the integer value ui. The data sources <NUM> send the encrypted data plus first noise value <NUM> to the secure data processor <NUM>; the data sources <NUM> also send the encrypted first noise value and the encrypted second noise value <NUM> to the model provider <NUM>. After computing ui as described above, the model provider <NUM> may decrypt the encrypted second noise value pi and remove it from the data value ui, as described above.

Referring to <FIG>, in some embodiments, the secure data processor <NUM>, model user <NUM>, and /or data sources <NUM> may use elliptic-curve cryptography to securely process, send, and/or receive data. Elliptic-curve cryptography utilizes an elliptic curve to encrypt data, as opposed to multiplying two prime numbers to create a modulus, as described above. An elliptic curve A is a plane curve over a finite field Fp of prime numbers that satisfies the below equation (<NUM>).

The finite field Fp of prime numbers may be, for example, the NIST P-<NUM> field defined by the U. National Institute of Standards and Technology (NIST). In some embodiments, elliptic curves over binary fields, such as NIST curve B-<NUM>, may be used as the finite field Fp of prime numbers. A key is represented as (x,y) coordinates of a point on the curve; an operator may be defined such that using the operator on two (x,y) coordinates on the curve yields a third (x,y) coordinate also on the curve. Thus, key transfer may be performed by transmitting only one coordinate and identifying information of the second coordinate.

The above elliptic curve may have a generator point, G, that is a point on the curve - e.g., G = (x,y) ∈ E. A number n of points on the curve may have the same order as G - e.g., n = o(G). The identity element of the curve E may be infinity. A cofactor h of the curve E may be defined by the following equation (<NUM>).

A first party, such as the model provider <NUM>, may select a private key nB that is less than o(G). In various embodiments, the secure data processor <NUM> is not the first party and thus does not know the private key nB. The first party may generate a public key PB in accordance with equation (<NUM>).

The first party may then transmit the public key PB to a second party, such as a data source <NUM>. The first party may similarly transmit encryption key data corresponding to domain parameters (p, a, b, G, n, h). The data source <NUM> may then encrypt data m using the public key PB. The data source <NUM> may first encode the data m; if m is greater than zero, the data source <NUM> may encode it in accordance with mG; m is less than zero, the data source <NUM> may encode it in accordance with (-m)G-<NUM>. If G = (x,y), G-<NUM> = (x,-y). In the below equations, however, the encoded data is represented as mG for clarity. The data source <NUM> may perform the encoding using, for example, a doubling-and-adding method, in O(log(m)) time.

To encrypt the encoded data mG, the data source <NUM> may select a random number c, wherein c is greater than zero and less than a finite field prime number p. The data source <NUM> may thereafter determine and send encrypted data in accordance with the below equation (<NUM>).

The model provider <NUM> may receive the encrypted data from the data source <NUM> and may first determine a product of the random number c and the public key PB in accordance with equation (<NUM>).

The model provider <NUM> may then determine a product of the data m and the generator point G in accordance with the below equation (<NUM>).

Finally, the model provider <NUM> may decode mG to determine the data m. This decoding, which may be referred to as solving the elliptic curve discrete logarithm, may be performed using, for example, a baby-step-giant-step algorithm in <MAT> time.

As shown in <FIG>, each data source <NUM> encrypts data vi using the public key PB and a selected random value c to create encrypted data <NUM> in accordance with the above equation (<NUM>). The data vi may be a <NUM>-bit signed integer value. The encrypted data <NUM> may correspond to a pair of integers; the first integer may be (ciG), and the second integer may be (viG + ciPB). Each data source <NUM> may then send the encrypted data <NUM> to the secure data processor <NUM> using, in some embodiments, a secure connection. Because, as described above, the encrypted data <NUM> is additively homomorphic, the secure data processor <NUM> may compute the sum <NUM> of the received data <NUM> in accordance with the above equations (<NUM>), (<NUM>), and/or (<NUM>). The secure data processor <NUM> may then send the sum <NUM> to the model provider <NUM>. The sum <NUM> may correspond to a pair of integers; the first integer may be Σ(ciG), and the second integer may be (ΣviG + ΣciPB).

The model provider <NUM> may decrypt the sum <NUM> by first determining the product of the sum of the random numbers c and the public key PB (i.e., the second half of the second integer of the sum <NUM>), using the first integer, the private key nB, and the generator G, in accordance with the below equation (<NUM>).

The model provider <NUM> may then determine the product of the sum of the data vi and G by subtracting the second half of the second integer of the sum <NUM> from the second integer of the sum <NUM> in accordance with the below equation (<NUM>).

The model provider <NUM> may then decode the sum ΣviG to determine Σvi using, as described above, a baby-step-giant-step algorithm.

In some embodiments, with reference also to <FIG> and associated text, the secure data processor <NUM>, model provider <NUM>, model user <NUM>, and/or data sources <NUM> send and receive data in blocks, such as <NUM>-bit blocks, which permits the sending and receiving of fixed point numbers and/or integers larger than <NUM> bits. The model provider <NUM> may determine an integer s in accordance with equation <NUM> and transmit the integer s to the data sources <NUM>. Each data source <NUM> may then convert a fixed point number to an integer in accordance with equation (<NUM>) and/or create a number <NUM>-bit blocks representing the number in accordance with equation (<NUM>) prior to sending encrypting and sending the data <NUM>.

<FIG> and <FIG> illustrate a secure data processor <NUM> for training a neural network according to embodiments of the present disclosure. A code encryption component <NUM> receives, from a model provider <NUM>, unencrypted code describing a model, such as a neural network. The model may include configurable values that control the output of the model given inputs to the model; these configurable values are referred to herein as weights (as described in greater detail with reference to <FIG>). The code encryption component <NUM> encrypts the code (which may include encrypting the model and/or weights associated with the model) using, for example, the encryption function H(m) described herein. The encryption function H(m), and its associated public and private encryption key data described herein, may be created by the model provider <NUM>, and the public encryption key data may be sent to the data sources <NUM>. In some embodiments, the encryption function H(m) and its associated public and private encryption key data is created by the model owner <NUM>. In these embodiments, the model owner <NUM> may use the encryption key data to decrypt a trained neural network, while the model provider <NUM> is prevented from decrypting the trained neural network. In these embodiments, the model owner <NUM> may additionally decrypt training data during training of the model, such as the performance metrics described herein.

A send/receive component <NUM> receives the encrypted computer instructions from the code encryption component <NUM>, which it may send to the data sources <NUM>. The send/receive component <NUM> further receives a set of initial weights from an initial-weight generation component <NUM>. The initial weights may be random values; the initial-weight generation component <NUM> may include, for example, a random-number generator and may generate fixed-point random numbers between <NUM> and <NUM> as the initial weights. Because the initial weights are random, if a third party were to possess only the weight updates, as described below, the third party would not be able to derive the actual weights at least because possession of both the weight updates and the initial weights is necessary to derive the actual weights.

The send/receive component <NUM> receives, from one or more data sources <NUM>, change data encrypted using the techniques described herein, such as by using the encryption function H(m). The encrypted change data may include changes in weights (i.e., weight updates) corresponding to a model, gradients corresponding to a model, and/or metrics of performance of the model as modified with the changes and/or gradients. Each data source <NUM> may create model-output data by applying, to a copy of the model, the values vi described herein using a secure data processor <NUM>, which may be a gradient-descent processor. Using the gradient descent techniques described herein, the secure data processor <NUM> applies the values vi to the model and determines, based on outputs of the model, one or more weight updates and/or one or metrics of accuracy of the outputs of the model.

The metrics may include, for example, a degree of similarity between outputs of the model and outputs expected from training data. A metric of <NUM> may, for example, indicate perfect similarity, while a metric of <NUM> may indicate no similarity. Based on the performance of the model, the secure data processor <NUM> further determines a set of weight updates. The weight updates may include positive or negative numbers indicating how much a particular weight should be increased or decreased. The weight updates may not include the actual weights. The secure data processor <NUM> may encrypt the change data (e.g., weight updates and/or corresponding metric updates) with an encryption function H(m) before sending them to the send/receive component <NUM>. The send/receive component <NUM> may then send the received encrypted weight updates to a weight-filtering component <NUM> and a metric-filtering component <NUM>, respectively.

The weight-filtering component <NUM> may filter the weight updates, and the metric-filtering component <NUM> may filter the metric updates. The filter components <NUM>, <NUM> may filter the weight and/or metric updates by removing updates greater than a first threshold or lower than a second threshold. The filter components <NUM>, <NUM> may further normalize the update data by applying a normalization function, such as a sigmoid function.

A weight-summing component <NUM> may sum the filtered weight updates over several iterations of operation of the gradient descent technique by the secure data processor <NUM>, and metric-summing component <NUM> may similarly sum the filtered metric updates over several iterations of operation of the gradient descent technique by the secure data processor <NUM> to create encrypted summation data, which may include the summed encrypted weights and/or summed encrypted metrics. As described herein, the summing components <NUM>, <NUM> may sum the filtered update data, because the data is additively homomorphic, by multiplying the data together.

Once the available data from the data sources <NUM> has been applied to the model and once the gradient descent technique has been applied by the secure data processor 128for all the data, a final weight decode component <NUM> create decrypted change data by decoding final summed weights, and a final metric decode component <NUM> may create decrypted change data by decoding final summed metrics using, for example, the decryption function H-<NUM>(c) described herein. A success/fail determination component <NUM> may compare the final metrics to a quality threshold; if the final metrics satisfy the threshold, the system may send the decrypted summation data, which may include the final summed weights, to the model user <NUM>.

With reference to <FIG>, the data sources <NUM> may add noise to their data prior to sending the data, as described herein. In these embodiments, the secure data processor <NUM> includes additional components to filter and add the data and noise: a weight-noise filter component <NUM>, a weight-and-noise filter component <NUM>, a metric-noise filter component <NUM>, a metric-and-noise filter component <NUM>, weight-noise summing component <NUM>, a weight-and-noise summing component <NUM>, a metric-noise summing component <NUM>, and a metric-and-noise summing component <NUM>. These components may process data in an analogous manner as the weight filter component <NUM>, the metric filter component <NUM>, the weight summing component <NUM>, and the metric summing component <NUM>, respectively, as described above. The final weight decode component <NUM> may receive the output of both the weight-noise summing component <NUM> and the weight-and-noise summing component <NUM> and may remove the noise from the weights, as described above. Similarly, the final metric decode component <NUM> may receive the output of both the metric-noise summing component <NUM> and the metric-and-noise summing component <NUM> and may remove the noise from the metrics. The success/fail determination component <NUM> may compare the final metrics to a quality threshold; if the final metrics satisfy the threshold, the system may send the final weights to the model user <NUM>.

<FIG> and <FIG> illustrate a flow diagram for transacting to build a neural network according to embodiments of the present disclosure. Referring first to <FIG>, the model user <NUM> sends, to a market <NUM>, a challenge <NUM> defining a problem the model user <NUM> wishes to solve. The market <NUM> may be, for example, an e-commerce website that coordinates transfer of data to and from the model provider <NUM> and the data sources <NUM>. For example, if the model user <NUM> is a power company, the model user <NUM> may wish the building of a model to predict failure of a component. The challenge <NUM> may also include a minimum accuracy of the model in predicting the failure. The challenge <NUM> may also include a minimum data quality and/or minimum data amount.

The secure data processor <NUM> and/or model provider <NUM> sends, to the market <NUM>, an indication <NUM> to initiate a search for available challenges. The indication <NUM> may include types of challenges that the secure data processor <NUM> and/or model provider <NUM> are capable of solving, compensation requirements, and/or timeframes for solving. The market <NUM> may send challenge search results <NUM> back to the secure data processor <NUM> and/or model provider <NUM>; the search results <NUM> may include an indication of the challenge <NUM>. Similarly, one or more data sources <NUM> may send an indication <NUM> to initiate a search for available challenges. The indication <NUM> may include the type of data that the data source <NUM> is offering, the quality of the data, and/or the amount of the data, as well as compensation requirements. The indication <NUM> may further include a requirement that the data source <NUM> also be a model user <NUM>. The market <NUM> may similarly send a result <NUM> back to the data source <NUM>; the result <NUM> may include an indication of the challenge <NUM>. If the secure data processor <NUM> and/or model provider <NUM> accepts the challenge, it may send an offer to solve <NUM> back to the market <NUM>; the data source <NUM> may similarly send an offer <NUM> to send data. The secure data processor, model provider <NUM>, and or market <NUM> may determine an estimated amount of computing resources required to solve the problem; this amount may be specified in, for example, the offer to solve <NUM>. The offer to solve <NUM> may include a payment amount request that is based on the estimated amount of computing resources.

The market <NUM> may send, to the model user <NUM>, an indication <NUM> to inspect the accepted offers. The model user <NUM> may evaluate the offers based on a number of criteria, such as completion time and cost. If the model user <NUM> accepts one or more offers, it sends a corresponding indication <NUM> of acceptance to the market <NUM>.

Once the offer is accepted, the model user <NUM> sends the agreed-upon payment to an escrow service <NUM>. Once the escrow service <NUM> receives the payment, it sends an indication <NUM> to start the challenge to a network <NUM>, such as the network <NUM>. The network <NUM> sends a corresponding indication <NUM> to start the challenge to the secure data processor <NUM> and/or model provider <NUM>.

The secure data processor <NUM> and/or model provider <NUM> writes code corresponding to the challenge and sends the written code <NUM> to the network <NUM>, which sends corresponding code <NUM> to one or more data sources <NUM>. The data sources <NUM> apply their data to the code and send the results <NUM> of the running the challenge to the escrow service <NUM>, which sends a corresponding solution <NUM> to the challenge to the model user. As discussed above, the solution <NUM> may be a set of weights and/or initial weights and weight updates for the model. The model user <NUM> may request additional challenges to further improve the model; for example, the model user <NUM> may send, to the market <NUM>, further requests for data. If the model user <NUM> accepts the solution <NUM>, the escrow service <NUM> sends a first payment <NUM> to the data source <NUM> and a second payment <NUM> to the secure data processor <NUM> and/or model provider <NUM>. In some embodiments, the payments are made using self-executing (i.e., "smart") contracts.

As mentioned above, a neural network may be trained to perform some or all of the computational tasks described herein. An example neural network <NUM> is illustrated in <FIG>. The neural network <NUM> may include nodes organized as an input layer <NUM>, one or more hidden layers <NUM>, and an output layer <NUM>. The input layer <NUM> may include m nodes, the hidden layer(s) <NUM> may include n nodes, and the output layer <NUM> may include o nodes, where m, n, and o may be any numbers and may represent the same or different numbers of nodes for each layer. Each node of each layer <NUM>, <NUM>, <NUM> may include computer-executable instructions and/or data usable for receiving one or more input values and for computing an output value. Each node may further include memory for storing the input, output, or intermediate values. One or more data structures, such as a long short-term memory (LSTM) cell or other cells or layers (as described in greater detail with reference to <FIG>), may additionally be associated with each node for purposes of storing different values. Nodes 602a, 602b,. <NUM> of the input layer <NUM> may receive inputs 608a, 608b,. <NUM>, and nodes 606a, 606b,. 606o of the output layer <NUM> may produce outputs 610a, 610b,. In some embodiments, the inputs 608a, 608b,. <NUM> correspond to data from a data source, and the outputs 610a, 610b,. 610o correspond to model output data. Each node 604a, 604b,. <NUM> of the hidden layer <NUM> may be connected to one or more nodes 602a, 602b,. <NUM> in the input layer <NUM> and one or more nodes 606a, 606b,. 606o in the output layer <NUM>. Although the neural network <NUM> illustrated in <FIG> includes a single hidden layer <NUM>, other neural networks may include multiple middle layers <NUM>; in these cases, each node in a hidden layer may connect to some or all nodes in neighboring hidden (or input/output) layers. Each connection from one node to another node in a neighboring layer may be associated with a weight or score. A neural network may output one or more outputs, a weighted set of possible outputs, or any combination thereof.

In some embodiments, a neural network is constructed using recurrent connections such that one or more outputs of the hidden layer of the network feeds back into the hidden layer again as a next set of inputs. Such a neural network <NUM> is illustrated in <FIG>. Each node of the input layer <NUM> connects to each node of the hidden layer(s) <NUM>; each node of the hidden layer(s) <NUM> connects to each node of the output layer <NUM>. As illustrated, one or more outputs <NUM> of the hidden layer(s) <NUM> is fed back into the hidden layer <NUM> for processing of the next set of inputs. A neural network incorporating recurrent connections may be referred to as a recurrent neural network (RNN). An RNN or other such feedback network may allow a network to retain a "memory" of previous states and information that the network has processed.

Processing by a neural network may be determined by the learned weights on each node input and the structure of the network. Given a particular input, the neural network determines the output one layer at a time until the output layer of the entire network is calculated. Connection weights may be initially learned by the neural network during training, where given inputs are associated with known outputs. In a set of training data, a variety of training examples are fed into the network. Each example typically sets the weights of the correct connections from input to output to <NUM> and gives all connections a weight of <NUM>. As examples in the training data are processed by the neural network, an input may be sent to the network and compared with the associated output to determine how the network performance compares to the target performance. Using a training technique, such as backpropagation, the weights of the neural network may be updated to reduce errors made by the neural network when processing the training data. In some circumstances, the neural network may be trained with an entire lattice to improve speech recognition when the entire lattice is processed.

<FIG> illustrates an exemplary long short-term memory (LSTM) cell <NUM> capable of learning long-term dependencies and which may be used in building one or more of the models described herein. The LSTM cell <NUM> receives an input vector xt and generates an output vector ht. The cell further maintains a cell state Ctthat is updated given the input xt, a previous cell state Ct-i, and a previous output ht-<NUM>. Using the previous state and input, a particular cell may take as input not only new data (xt) but may also consider data (Ct-<NUM> and ht-<NUM>) corresponding to the previous cell. The output ht and new cell state Ct are created in accordance with a number of neural network operations or "layers," such as a "forget gate" layer <NUM>, an "input gate" layer <NUM>, a tanh layer <NUM>, and a sigmoid layer <NUM>.

The forget gate layer <NUM> may be used to remove information from the previous cell state Ct-<NUM>. The forget gate layer <NUM> receives the input xt and the previous output ht-<NUM> and outputs a number between <NUM> and <NUM> for each number in the cell state Ct-i. A number closer to <NUM> retains more information from the corresponding number in the cell state Ct-i, while a number closer to <NUM> retains less information from the corresponding number in the cell state Ct-i. The output ft of the forget gate layer <NUM> may be defined by the below equation (<NUM>). The layer <NUM> may be modified by changing one or more of the weights σ, Wf, and/or bf.

The input gate layer <NUM> and the tanh layer <NUM> may be used to decide what new information should be stored in the cell state Ct-i. The input gate layer <NUM> determines which values are to be updated by generating a vector it of numbers between <NUM> and <NUM> for information that should not and should be updated, respectively. The tanh layer <NUM> creates a vector Ct of new candidate values that might be added to the cell state Ct. The vectors it and Ct, defined below in equations (<NUM>) and (<NUM>), may thereafter be combined and added to the combination of the previous state Ct-i and the output ft of the forget gate layer <NUM> to create an update to the state Ct. The layers <NUM>, <NUM> may be modified by changing one or more of the weights σ, Wi, bi, Wc, and/or bc. <MAT> <MAT>.

Once the new cell state Ct is determined, the sigmoid layer <NUM> may be used to select which parts of the cell state Ct should be combined with the input xt to create the output ht. The output ot of the sigmoid layer <NUM> and output ht may thus be defined by the below equations (<NUM>) and (<NUM>). These values may be further updated by sending them again through the cell <NUM> and/or through additional instances of the cell <NUM>. The sigmoid layer <NUM> may be modified by changing one or more of the weights σ, σt, Wo, and/or bo. <MAT> <MAT>.

The model(s) discussed herein may be trained and operated according to various machine learning techniques. Such techniques may include, for example, neural networks (such as deep neural networks and/or recurrent neural networks), inference engines, trained classifiers, etc. Examples of trained classifiers include Support Vector Machines (SVMs), neural networks, decision trees, AdaBoost (short for "Adaptive Boosting") combined with decision trees, and random forests. Focusing on SVM as an example, SVM is a supervised learning model with associated learning algorithms that analyze data and recognize patterns in the data, and which are commonly used for classification and regression analysis. Given a set of training examples, each marked as belonging to one of two categories, an SVM training algorithm builds a model that assigns new examples into one category or the other, making it a non-probabilistic binary linear classifier. More complex SVM models may be built with the training set identifying more than two categories, with the SVM determining which category is most similar to input data. An SVM model may be mapped so that the examples of the separate categories are divided by clear gaps. New examples are then mapped into that same space and predicted to belong to a category based on which side of the gaps they fall on. Classifiers may issue a "score" indicating which category the data most closely matches. The score may provide an indication of how closely the data matches the category.

In order to apply the machine learning techniques, the machine learning processes themselves need to be trained. Training a machine learning component such as, in this case, one of the first or second models, may require establishing a "ground truth" for the training examples. In machine learning, the term "ground truth" refers to the accuracy of a training set's classification for supervised learning techniques. For example, known types for previous queries may be used as ground truth data for the training set used to train the various components / models. Various techniques may be used to train the models including backpropagation, statistical learning, supervised learning, semi-supervised learning, stochastic learning, stochastic gradient descent, or other known techniques. Thus, many different training examples may be used to train the classifier(s) / model(s) discussed herein. Further, as training data is added to, or otherwise changed, new classifiers / models may be trained to update the classifiers / models as desired. The model may be updated by, for example, back-propagating the error data from output nodes back to hidden and input nodes; the method of back-propagation may include gradient descent.

In some embodiments, the trained model is a deep neural network (DNN) that is trained using distributed batch stochastic gradient descent; batches of training data may be distributed to computation nodes where they are fed through the DNN in order to compute a gradient for that batch. The secure data processor <NUM> may update the DNN by computing a gradient by comparing results predicted using the DNN to training data and back-propagating error data based thereon. In some embodiments, the DNN includes additional forward pass targets that estimate synthetic gradient values and the secure data processor <NUM> updates the DNN by selecting one or more synthetic gradient values.

<FIG> is a block diagram illustrating a computing environment that includes a server <NUM>; the server <NUM> may be the secure data processor <NUM>, model provider <NUM>, model user <NUM>, and/or data source <NUM>. The server <NUM> may include one or more input/output device interfaces <NUM> and controllers/processors <NUM>. The server <NUM> may further include storage <NUM> and a memory <NUM>. A bus <NUM> may allow the input/output device interfaces <NUM>, controllers/processors <NUM>, storage <NUM>, and memory <NUM> to communicate with each other; the components may instead or in addition be directly connected to each other or be connected via a different bus.

A variety of components may be connected through the input/output device interfaces <NUM>. For example, the input/output device interfaces <NUM> may be used to connect to the network <NUM>. Further components include keyboards, mice, displays, touchscreens, microphones, speakers, and any other type of user input/output device. The components may further include USB drives, removable hard drives, or any other type of removable storage.

The controllers/processors <NUM> may processes data and computer-readable instructions, and may include a general-purpose central-processing unit, a specific-purpose processor such as a graphics processor, a digital-signal processor, an application-specific integrated circuit, a microcontroller, or any other type of controller or processor. The memory <NUM> may include volatile random access memory (RAM), non-volatile read only memory (ROM), non-volatile magnetoresistive (MRAM), and/or other types of memory. The storage <NUM> may be used for storing data and controller/processor-executable instructions on one or more non-volatile storage types, such as magnetic storage, optical storage, solid-state storage, etc..

Computer instructions for operating the server <NUM> and its various components may be executed by the controller(s)/processor(s) <NUM> using the memory <NUM> as temporary "working" storage at runtime. The computer instructions may be stored in a non-transitory manner in the memory <NUM>, storage <NUM>, and/or an external device(s). Alternatively, some or all of the executable instructions may be embedded in hardware or firmware on the respective device in addition to or instead of software.

<FIG> illustrates a number of devices in communication with the secure data processor <NUM>, model provider <NUM>, model user <NUM>, and/or data source <NUM> using the network <NUM>. The devices may include a smart phone <NUM>, a laptop computer <NUM>, a tablet computer <NUM>, and/or a desktop computer <NUM>. These devices may be used to remotely access the secure data processor <NUM>, model provider <NUM>, model user <NUM>, and/or data source <NUM> to perform any of the operations described herein.

The above aspects of the present disclosure are meant to be illustrative. They were chosen to explain the principles and application of the disclosure and are not intended to be exhaustive or to limit the disclosure. Many modifications and variations of the disclosed aspects may be apparent to those of skill in the art. Persons having ordinary skill in the field of computers and speech processing should recognize that components and process steps described herein may be interchangeable with other components or steps, or combinations of components or steps, and still achieve the benefits and advantages of the present disclosure. Moreover, it should be apparent to one skilled in the art that the disclosure may be practiced without some or all of the specific details and steps disclosed herein.

Aspects of the disclosed system may be implemented as a computer method or as an article of manufacture such as a memory device or non-transitory computer readable storage medium. The computer readable storage medium may be readable by a computer and may comprise instructions for causing a computer or other device to perform processes described in the present disclosure. The computer readable storage medium may be implemented by a volatile computer memory, non-volatile computer memory, hard drive, solid-state memory, flash drive, removable disk, and/or other media. In addition, components of one or more of the modules and engines may be implemented as in firmware or hardware, which comprises, among other things, analog and/or digital filters (e.g., filters configured as firmware to a digital signal processor (DSP)).

Conditional language used herein, such as, among others, "can," "could," "might," "may," "e.g.," and the like, unless specifically stated otherwise, or otherwise understood within the context as used, is generally intended to convey that certain embodiments include, while other embodiments do not include, certain features, elements and/or steps. Thus, such conditional language is not generally intended to imply that features, elements and/or steps are in any way required for one or more embodiments or that one or more embodiments necessarily include logic for deciding, with or without other input or prompting, whether these features, elements and/or steps are included or are to be performed in any particular embodiment.

Claim 1:
A computer-implemented method comprising:
sending, from a first system to a first data source, encryption key data;
sending, from the first system to a second data source, the encryption key data;
receiving, at a second system from the first data source, first encrypted input data, the first encrypted input data being encrypted based at least in part on the encryption key data;
receiving, at the second system from the second data source, second encrypted input data, the second encrypted input data being encrypted based at least in part on the encryption key data;
generating, by the second system, encrypted summation data corresponding to a sum of the first encrypted input data and the second encrypted input data, wherein the second system is not in possession of the encryption key data, and wherein the first encrypted input data and the second encrypted input data are additively homomorphic;
sending, from the second system to the first system using a secure connection, the encrypted summation data, wherein the first system is trusted to learn the sum of data from each of the first and second data sources; and
generating, by the first system, summation data by decrypting, based at least in part on the encryption key data, the encrypted summation data.