Patent Publication Number: US-2022237456-A1

Title: Design and Training of Binary Neurons and Binary Neural Networks with Error Correcting Codes

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application is a continuation of International Application No. PCT/EP2019/078362, filed on Oct. 18, 2019, the disclosure of which is hereby incorporated by reference in its entirety. 
    
    
     TECHNICAL FIELD 
     This disclosure relates to deep neural networks, particularly to the design and training of binary neurons and binary neural networks. 
     BACKGROUND 
     Deep Neural Networks (DNNs) are computing systems inspired by the biological neural networks that constitute biological brains. DNNs “learn” to perform tasks by considering examples, generally without being programmed with any task-specific rules. For example, in image recognition, they might learn to identify images that contain cars by analyzing example images that have been manually labeled as “car” or “no car” and using the results to identify cars in other images. They do this without any prior knowledge about cars. Instead, they automatically generate identifying features from the learning material that they process.  FIG. 1  shows a general scheme of this process. 
     A DNN is based on a collection of connected units or nodes called artificial neurons, which loosely model the neurons in a biological brain. Each connection, like the synapses in a biological brain, can transmit a signal from one artificial neuron to another. An artificial neuron that receives a signal can process it and then activate additional artificial neurons connected to it. Typically, artificial neurons are aggregated into layers, where different layers may perform different kinds of transformations on their inputs. 
     In common DNN implementations, the signal at a connection between artificial neurons is a real number, and the output of each artificial neuron is computed by some non-linear function of the sum of its inputs. The connections between artificial neurons are called ‘edges’. The edges typically have a weight that adjusts as learning proceeds. The weight increases or decreases the strength of the signal at a connection. Artificial neurons may have a threshold such that the signal is only sent if the aggregate signal crosses that threshold. 
     A single artificial neuron is shown in  FIG. 2 . The inputs (x 1 , x 2 , . . . , x n ) can either be the input signal, or the outputs of the previous neuron layer. Each input x i  is first multiplied with a weight w ij , where j indicates the neuron index, and then the products are summed. In some cases, a bias w 0j  is added to this sum. Then the net input is passed through a non-linear activation function, and finally a single output y j  is produced. 
     DNNs are ubiquitous today, permeating every aspect of modern communication networks. Therefore, it comes as no surprise that DNNs are expected to play a very important role in devices in future networks, such as smartphones, sensors and wearables. Especially for smartphones, there is already a big market for DNNs, with various diverse applications, including image recognition, portrait mode photography, text prediction, user profiling, de-noising and camera enhancement. 
     However, their implementation on such resource constrained devices is limited by the high resource consumption (memory and energy). In the standard implementation of DNNs, all inputs, outputs, weights, biases, and activation functions are considered to be real numbers, and are typically represented in computers with floating point arithmetic, meaning that each number is approximated using a 64-bit sequence. In deep learning applications, there may be DNNs with thousands of neurons, where each neuron may have numerous inputs, resulting in millions of such floating point numbers. 
     For this reason, recent research has focused on compressing DNNs using a smaller-digit arithmetic, i.e., binary, ternary, or 8-bit. Such an approach essentially represents each number (input, output, weight) with less bits than a float would use. However, decreasing the representation bits has a detrimental effect on accuracy. For the same number of neurons, each neuron is now less potent in describing relations, and therefore an error may be introduced. On the other hand, it is possible to increase the number of neurons and theoretically achieve the same accuracy as before. For example, in the worst-case, 64 binary neurons can simulate a floating point neuron. However, the hope in recent research is that this can be improved if binary neural networks can be properly designed. 
     Prior work has identified that reducing the arithmetic precision can greatly enhance the performance of the DNNs without necessarily sacrificing accuracy. However, training of low-precision DNNs becomes the new bottleneck and is one of the key problems in the domain of machine learning today. 
     I. Hubara, M. Courbariaux, D. Soudry, R. El-Yaniv, and Y. Bengio, “Quantized Neural Networks: Training Neural Networks with Low Precision Weights and Activations”, Journal of Machine Learning Research, 18(187), 1-30, 2017, and M. Rastegari, V. Ordonez, J. Redmon, and A. Farhadi, “XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks”, European Conference on Computer Vision, 525-542, 2016, provides designs of binary neural networks (BNNs) that reduce memory usage by 32 times, achieve a tenfold decrease in energy consumption, and reduce significantly inference time compared to DNNs with continuous weights. These results justify the quest for developing low-precision NN architectures and training algorithms which achieve accuracies close to those achieved by their continuous-weights counterparts. 
     However, training a neural network with low-precision weights (even a single-layer one) is known to be an NP-hard optimization problem. In particular, due to weight discretization, the backpropagation algorithm used in continuous DNNs, which is based on computing the gradient of the loss function, cannot be used effectively. The problem of unstable gradients appears as soon as the number of bits for representing numbers is less than 8. 
     Thus, most prior work in efficient training of low-precision neural networks is based on the use of gradient approximations, which require storing a floating point weight along with the low precision weight and performing some form of backpropagation with floating point arithmetic (thus relinquishing some of the discretization advantage). 
     In order to address this issue, these works keep a full precision value for each weight and then (i) binarize this value and (ii) update the full precision value by a straight-through estimator for the gradient evaluated on the binarized value. 
     The algorithm described in C. Leng, Z. Dou, H. Li, S. Zhu, R. Jin, “Extremely Low Bit Neural Network: Squeeze the Last Bit Out with ADMM”, The Thirty-Second AAAI Conference on Artificial Intelligence (AAAI-18), 3466-3473, also stores two versions of the weights: a low precision and a high precision one, and seeks to optimize a function that severely penalizes the distance between the two, thus forcing the high precision weights to take values very close to the low precision ones. 
     An alternative approach based on Bayesian modelling is described in D. Soudry, I Hubara, R. Meir, “Expectation Backpropagation: parameter-free training of multilayer neural networks with continuous or discrete weights”, 27th International Conference on Neural Information Processing Systems (NIPS), 2014, wherein each weight is characterized by a probability distribution, which is updated at training. The BNN is then specified by sampling weights from given distributions. Procedures along these lines can produce BNNs during training, but they still need to operate on full precision real numbers, thus they are unsuitable for use on battery-powered devices. 
     Another approach to train BNNs are algorithms inspired from statistical physics. The approaches in C. Baldassi and A. Braunstein, “A Max-Sum algorithm for training discrete neural networks”, Journal of Statistical Mechanics: Theory and Experiments, August 2015, and C. Baldassi, “Generalization Learning in a Perceptron with Binary Synapses”, Journal of Statistical Physics, vol. 136, no. 5, 902-916, September 2009, provide training algorithms that keep and update an integer “hidden weight” for every binary weight. It has been illustrated that these integer hidden weights can also have bounded magnitude. This feature greatly reduces the complexity of operations, making these algorithms more attractive for on-device use. However, the algorithms are designed for specific types of networks and cannot be applied in a straightforward manner to more general and deep architectures. 
     The work in C. Baldassi, A. Ingrosso, C. Lucibello, L. Saglietti, R. Zecchina, “Subdominant Dense Clusters Allow for Simple Learning and High Computational Performance in Neural Networks with Discrete Synapses”, Physical Review Letters, vol. 115, no. 12, September 2015, provides an efficient algorithm based on belief propagation, but as in the previous works, this applies to a single perceptron and it is unclear how to use it for networks with multiple layers. 
     An alternative approach to overcome the lack of gradient information is to address training as a combinatorial optimization problem and apply a known solution method for this kind of problems. For example, Evolutionary Algorithms (EA) have been proposed as a training method for NNs in general, as described in G. Morse and K. O. Stanley, “Simple Evolutionary Optimization Can Rival Stochastic Gradient Descent in Neural Networks”, The Genetic and Evolutionary Computation Conference (GECCO), July 2016, and low-precision DNNs in particular, as described in R. Ito and T. Saito, “Dynamic binary neural networks and evolutionary learning”, The International Joint Conference on Neural Networks (IJCNN), July 2010. 
     However, EAs suffer from performance and scalability issues. Firstly, although only low-precision weights are considered, the number of weights stored in memory is multiplied by the population size, and therefore, even for binary weights and a modest population size of 100, the memory footprint is larger than storing decimal weights with 16, 32 or 64 bits floating point representation. Secondly, a single forward pass during training has to be performed for all members of the population. Even though this can be done in parallel, having as many parallel processors as the population size is prohibitive for training on a mobile device. Finally, it is well known that the population size should increase with the number of weights (dimension of the optimization parameter space), making scaling for big neural networks problematic. 
     Thus, there exists no known scalable and efficient algorithm in the literature to train a low-precision DNN purely on a smartphone. Consequently, the current state of the art approach is to perform the computationally demanding training phase by using floating point arithmetic on the cloud, where the resource limitations are relaxed. Then, a low-precision version of the DNN is provided on the smartphone to perform the less demanding inference (feedforward) phase on unseen data. However, this is a procedure that can produce only a fixed pre-trained low-precision DNN, which is a major limitation of the prior art. 
     Low-precision neural networks can be implemented in software or hardware. Binary neural networks in particular, are known to have very efficient implementations based on bitwise operations (in software) or digital logic circuits such as NOR or XNOR (in hardware). 
     WO 1992012497 A1 and U.S. Pat. No. 10,089,577 B2 describe the use of specific hardware designs for a neuron for implementing BNNs. WO 1992012497 A1 concerns neural networks used as associative memories and implements each neuron as a ‘NOR’ logic function so that its output is active only if all its inputs are inactive. In U.S. Pat. No. 10,089,577 B2, XNOR is performed between the input signals of each neuron and the corresponding weights and then the number of resulting 1s is compared against a threshold to determine the output (activation function). Moreover, no training method is proposed. 
     It is desirable to design binary neurons and neural networks in order to completely binarize DNNs, enabling artificial intelligence (AI) in smartphones with compact AI chipsets, reduced energy consumption and training acceleration. 
     SUMMARY 
     According to a first aspect, there is provided a data processing system having a neural network architecture for receiving a binary network input and in dependence on the network input propagating signals via a plurality of processing nodes, in accordance with respective binary weights, to form a network output, the data processing system being configured to train a node by implementing an error correcting function to identify a set of binary weights which minimize, for a given input to that node, any error between the node&#39;s output when formed in accordance with the node&#39;s current weights and a preferred output from the node and to update the weights of that node to be the identified weights. This training may be performed in the binary field without storing and/or using any higher arithmetic precision weights or other components. 
     The approach may therefore train a “binary field” neuron and/or neural network without storing and/or using any higher arithmetic precision weights or other components. The approach can be implemented on artificial intelligence chipsets in a simple, standalone, and modular manner, as required for mass production. This solution may present minor losses in accuracy for dramatic benefits in simplicity, space, thermal properties, memory requirements, and energy consumption and can be used for federated learning, user profiling, privacy, security and optimal control. The approach takes one step closer to a precise form of Boolean functions to be used, inspired by properties from the channel coding theory. 
     The said node may be configured to receive a node input dependent on the network input and to form a node output that is binary and is functionally equal to the sum in the binary field of (i) a first weight, (ii) the sum in the binary field of the products of (a) each of the bits of the node input and (b) a respective one of a set of second weights and (iii) a value indicative of whether all the bits of the node input are non-zero. This may provide an efficient way of implementing a flexible computation node. 
     The said one of the nodes may be configured to form a node output that is functionally equal to a coset of the first order Reed-Muller code wherein the coset kernel takes as input the bits of the node input. This may permit the node to efficiently process binary data. 
     The node may be implemented as a set of logic circuits configured so that: 
     (i) each bit of the node input is subject to a logical AND function with a respective weight to form a respective first intermediate value; 
     (ii) all bits of the node input are together subject to a logical AND function to form a second intermediate value; and 
     (iii) a further weight, the first intermediate values and the second intermediate value are together subject to a logical XOR function to form the node output. This may facilitate efficient processing of binary data. 
     The network may comprise a plurality of blocks, each block comprising at least three logic circuits as set out as described above, those logic circuits being configured so that first and second ones of those logic circuits receive block inputs dependent on the network input and form first and second intermediate block values, and the third one of those logic circuits receives as input the intermediate block values and forms an output from the block. A block of this form can efficiently form a component of more complex computational structures. The interconnections between the blocks may depend on the desired boolean function to be implemented. 
     The first logic circuit may be configured to apply weights as the weights of a binary perceptron and the second logic circuit may have fixed weights. The fixed weights may be zero. This can permit the first logic circuit to efficiently process input data. 
     The third logic circuit may receive as input (i) a single instance of the first intermediate block value and (ii) multiple instances of the second intermediate block value. This can allow the third logic circuit to process data in an efficient manner. 
     The third logic circuit may be configured to apply fixed weights to all its inputs with the exception of one instance of the second intermediate block value. This can allow the third logic circuit to process data in an efficient manner. 
     The third logic circuit may be configured to apply a weight equal to the sum in the binary field of the weights of the first logical circuit to the said instance of the second intermediate block value. This can allow the third logic circuit to process data in an efficient manner. 
     The data processing system may comprise a plurality of sub-systems, the sub-systems each comprising a system as described above, wherein the system is configured to provide the output of at least one of the sub-systems as an input to at least one of the other sub-systems. The connections between the plurality of sub-systems may be configured in dependence on the desired Boolean function to be implemented. 
     The system may be configured to adapt the weights for a node in dependence on a set of expected node outputs expected for a set of node inputs by the steps of: forming a set of values representing, for each node input, whether the expected node output is (i) zero, (ii) one or (iii) indifferent; and identifying an i th  row of a Hadamard matrix that best matches the set of values; and adapting the weights for the node in dependence on that identification. The weights for the node may be adapted using any procedure for decoding an error-correcting code. This can allow the system to efficiently learn in response to input data. 
     The system may be configured to form a set of values representing, for each node input, whether the respective node output after the weights have been adapted matches the expected node output. This may be performed using any procedure for decoding error-correcting codes. This can provide feedback to the learning process. 
     The system may be configured to adapt the weights for a node in dependence on a set of expected node outputs expected for a set of node inputs by operating a fast Walsh-Hadamard function taking as input the set of expected node outputs. This can provide feedback to the learning process. 
     According to a second aspect, there is provided a communication terminal comprising a sensor and a data processing system as described above, the terminal being configured to sense data by means of the sensor to form the network input. 
     The sensor may be a camera. 
     The terminal may be configured to perform error correction on data received over a communication link using the said data processing system. 
     According to a third aspect, there is provided a computer program for implementation in a system having a neural network architecture for receiving a binary network input and in dependence on the network input propagating signals via a plurality of processing nodes, in accordance with respective binary weights, to form a network output, which, when executed by a computer, causes the computer to perform a method comprising training a node by implementing an error correcting function to identify a set of binary weights which minimize, for a given input to that node, any error between the node&#39;s output when formed in accordance with the node&#39;s current weights and a preferred output from the node and to update the weights of that node to be the identified weights. The computer program may be provided on a non-transitory computer readable storage medium. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present disclosure will now be described by way of example with reference to the accompanying drawings. In the drawings: 
         FIG. 1  shows a diagram of the stages of neural network training. 
         FIG. 2  illustrates an artificial neuron. 
         FIG. 3  illustrates a Fast Walsh Hadamard transform flow diagram. 
         FIG. 4  shows an example of a circuit of three inputs implementing the activation function of the binary field neuron. 
         FIG. 5  shows a symbol to indicate binary field neuron of M inputs. 
         FIG. 6A  shows a circuit of the binary field perceptron. 
         FIG. 6B  shows the symbol of the circuit in  FIG. 6A . 
         FIG. 7A  shows a circuit that can implement a Boolean monomial, a Boolean term or a weighted OR gate. 
         FIG. 7B  shows a symbol to indicate a Boolean monomial. 
         FIG. 7C  shows a symbol to indicate a Boolean term. 
         FIG. 8  shows a circuit that can implement the algebraic normal form (ANF of any Boolean function. From layer 4 to the output neuron (n layers in total) the number of neurons in each layer is indicated at the top. 
         FIG. 9A  shows a symbol used to indicate an OR gate where the inputs over which to perform the OR operation can be selected (“weighted OR”). 
         FIG. 9B  shows a symbol to indicate an OR gate where the operation is applied taking into account all inputs (equivalent to weighted OR with α i =1, i=1, . . . , M). 
         FIG. 10  shows a circuit that can implement the DNF of any Boolean function. From layer 4 to the output neuron (n layers of OR gates in total), the number of OR gates in each layer is indicated at the top. 
         FIG. 11  shows an example of a data processing system. 
     
    
    
     DETAILED DESCRIPTION OF ILLUSTRATIVE EMBODIMENTS 
     The present disclosure proposes a purely binary neural network, by introducing an architecture that is based on binary field arithmetic and transforms the training problem into a communication channel decoding problem. 
     An artificial neuron has a number of inputs and weights and returns one output. It is commonly seen as a function which is parameterized by the weights and takes a neuron&#39;s inputs as variables to return the output. In the context of BNNs, of particular concern is the development of binary neurons whose inputs, weights, and output are all binary numbers. Interestingly, such structure of binary neuron fits with Boolean functions. 
     Let m be the number of variables and x=(x 1 , x 2 , . . . , x m )∈F 2   m  be a binary m-tuple. A Boolean function is any function ƒ(x)=ƒ(x 1 , x 2 , . . . , x m ) that takes values in F 2 . It can be specified by a truth table which defines the value of ƒ at all of the 2 m  input combinations. Table 1 gives an example of the truth table of a binary sum function (XOR function). 
     
       
         
           
               
             
               
                 TABLE 1 
               
             
            
               
                   
               
               
                 Example of a truth table of a Boolean function (XOR). 
               
            
           
           
               
               
               
            
               
                 x 1   
                 x 2   
                 f = x 1  + x 2   
               
               
                   
               
               
                 0 
                 0 
                 0 
               
               
                 0 
                 1 
                 1 
               
               
                 1 
                 0 
                 1 
               
               
                 1 
                 1 
                 0 
               
               
                   
               
            
           
         
       
     
     The Boolean function ƒ is specified by a binary vector of length 2 m , thus there are in total 2 2     m    functions of m variables. Since x i   2 =x i  for x i ∈F 2 . Since 4, =x i  for x i  E F 2  , any Boolean function is a binary combination of the basis functions: 
       {1, x i , x i x j,j≠i , x i x j,≠i x k,k≠i,j , . . . , x 1 x 2  . . . x m }  (1)
 
     Boolean functions provide a natural way for modeling binary neurons, in particular from the feedforward perspective where the neuron acts like a function to give an output from the provided inputs. From this perspective, training a binary neuron is equivalent to fitting a Boolean function, i.e. finding a function that best approximates an output target when given a specific input. This formulation allows to apply well-known tools to solve the function fitting and thus also the neuron training, as explained next. 
     Boolean functions that express error correcting codes appear as a concrete and suitable candidate for binary neuron implementation due to their key advantage: as a code they have a built-in structure which translates the function fitting into a decoding task in a straightforward manner. 
     The present disclosure proposes binary field neurons that can be conveniently trained using channel coding theory and a number of circuits built using exclusively this type of neurons that have the capability of solving any learning problem with discrete inputs and discrete outputs. 
     The latter is possible thanks to (i) the capability of the proposed neuron activation function of generating non-linear functions of its inputs, and (ii) the fact that with a sufficient number of such neurons connected in a convenient manner any Boolean function can be implemented by the network. This implies that potentially any combination of inputs and labels can be learned by the system. 
     Furthermore, for fixed inputs, the function implemented by the neuron is linear in the neuron parameters, which allows to see the weight vector of each neuron as a specific error correcting code and thus to formulate the neuron training problem as a channel decoding problem. 
     Details of an exemplary binary field neuron and a number of circuits built with it that have the capability to solve any binary classification problem with binary inputs will now be described. Since any M-label classification problem can be formulated as M one-against-all binary classifications, the circuits presented here can be extended to build multiple-label classifiers with binary inputs. 
     In this example, the weight vector of each binary field neuron is a Reed-Muller code, which is an error-correcting code that can be simply defined in terms of Boolean functions. For m&gt;0 and 0≤r≤m, the r-th order Reed-Muller code, denoted R(r, m), is the set of all vectors f∈F 2   n  with n=2 m  obtained from Boolean function ƒ(x 1 , x 2 , . . . , x m ) which is a Boolean polynomial of degree at most r. 
     The r-th order Reed-Muller code consists of all linear combinations of the column vectors corresponding to basis functions of at most degree r in Equation (1). There are 
     
       
         
           
             d 
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   0 
                 
                 r 
               
               ⁢ 
               
                 ( 
                 
                   
                     
                       m 
                     
                   
                   
                     
                       r 
                     
                   
                 
                 ) 
               
             
           
         
       
     
     such basis vectors, which are linear independent. Thus, the code has dimension d and corresponds to a Boolean function with a truth table that consists of 2 d  columns of length 2 m . 
     The r-th order Reed-Muller code has minimum distance 2 m−r . Higher code order increases the codebook size and the approximation accuracy, but reduces the minimum distance and makes the neuron less robust to miss-fitting data, which is in turn an important requirement. 
     A particular and interesting case is the 1st-order Reed-Muller code R(1, m), which has the greatest minimum distance between Reed-Muller codes. It consists of 2 m+1  linear Boolean functions given by: 
     
       
         
           
             
               
                 
                   
                     
                       f 
                       ⁡ 
                       
                         ( 
                         x 
                         ) 
                       
                     
                     = 
                     
                       
                         w 
                         0 
                       
                       + 
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           m 
                         
                         ⁢ 
                         
                           
                             x 
                             i 
                           
                           ⁢ 
                           
                             w 
                             i 
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
     where x=(x 1 , x 2 , . . . , x m )∈F 2   m  are the input variables and w=(w 0 , w 1 , w 2 , . . . w m )∈F 2   m+1  are the parameters specifying ƒ. The 1st-order Reed-Muller code not only has the greatest minimum distance, but it is also computationally efficient thanks to its Hadamard-structure codebook that allows to perform computationally efficient decoding. It is however worth noting that the 1st-order Reed-Muller code is purely linear, see Equation (2), whereas, conceptually, artificial neurons are required to be able to express both linear and non-linear functions. Fortunately, the advantages of the 1st-order Reed-Muller code may be retained and at the same time satisfy the non-linearity expressibility requirement. That is done by using cosets of the 1st-order Reed-Muller code CR(1, m) which are defined by: 
     
       
         
           
             
               
                 
                   
                     
                       f 
                       ⁡ 
                       
                         ( 
                         x 
                         ) 
                       
                     
                     = 
                     
                       
                         w 
                         0 
                       
                       + 
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           m 
                         
                         ⁢ 
                         
                           
                             x 
                             i 
                           
                           ⁢ 
                           
                             w 
                             i 
                           
                         
                       
                       + 
                       
                         
                           ∏ 
                           
                             i 
                             = 
                             1 
                           
                           m 
                         
                         ⁢ 
                         
                           x 
                           i 
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
     where the product on the right-hand side is the cosets kernel which provides the neuron with the capability of expressing the non-linear part. It is clear that the kernel is equal to 1 if x i =1, ∀i, and o otherwise. The truth table of CR (1, m) is directly obtained from that of R (1, m) by just taking the binary complement of the last row. As a result, the Hadamard-structure codebook can be easily leveraged as in R(1, m) for efficient decoding of CR(1, m) 
     In this line of thought, the process of training a neuron is equivalent to finding the best training variables w that correspond to the best realizable function, according to a given optimization criterion. This problem is similar to a decoding problem, where the optimization criterion can be, for example, the minimization of errors between the desired truth table and the realizable function and the maximization of accuracy for the input training data set. 
     An example of realizable functions for CR(1,2) is shown in Table 2. This table shows the set of 2 m+1 =8 realizable functions that are decodable without errors. In general there are 2 2     m   =16 possible functions, which means that any truth table function that does not belong in the set of Table 2 has one or more errors for a specific x. 
     
       
         
           
               
             
               
                 TABLE 2 
               
             
            
               
                   
               
               
                 Example of realizable functions for m = 2 binary inputs 
               
            
           
           
               
               
            
               
                   
                 Output y = Σ i w i x i  + w 0  + Π i x i   
               
            
           
           
               
               
               
               
               
               
               
               
               
            
               
                 Input 
                 w = [0, 0] 
                 w = [0, 1] 
                 w = [1, 0] 
                 w = [1, 1] 
                 w = [0.0] 
                 w = [0, 1] 
                 w = [1, 0] 
                 w = [1, 1] 
               
               
                 x = [x 1 , x 2 ] 
                 w 0  = 0 
                 w 0  = 0 
                 w 0  = 0 
                 w 0  = 0 
                 w 0  = 1 
                 w 0  = 1 
                 w 0  = 1 
                 w 0  = 1 
               
               
                   
               
            
           
           
               
               
               
               
               
               
               
               
               
               
            
               
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 1 
                 1 
                 1 
               
               
                 0 
                 1 
                 0 
                 1 
                 0 
                 1 
                 1 
                 0 
                 1 
                 0 
               
               
                 1 
                 0 
                 0 
                 0 
                 1 
                 1 
                 1 
                 1 
                 0 
                 0 
               
               
                 1 
                 1 
                 1 
                 0 
                 0 
                 1 
                 0 
                 1 
                 1 
                 0 
               
               
                   
               
            
           
         
       
     
     An example of a method to decode a neuron will now be described. 
     The Hadamard-structure codebook for CR(1, m) code, whose Boolean function is described in Equation (3), can be leveraged in order to find the best training variables w given a target truth-table. This is achieved by using the Walsh-Hadamard transform. 
     A Walsh matrix is a specific square matrix of dimensions 2 n  with n={1,2, . . . }. For each entry h ik  of the matrix, h ik ∈{−1,1} and all rows and columns are orthogonal, i.e. the dot product equals to zero. The naturally ordered Walsh matrix is called Hadamard matrix, which is given by the recursive formula: 
     
       
         
           
             
               
                 
                   
                     
                       
                         H 
                         ⁡ 
                         
                           ( 
                           
                             2 
                             n 
                           
                           ) 
                         
                       
                       = 
                       
                         [ 
                         
                           
                             
                               
                                 H 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     2 
                                     
                                       n 
                                       - 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 H 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     2 
                                     
                                       n 
                                       - 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           
                             
                               
                                 H 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     2 
                                     
                                       n 
                                       - 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               
                                 - 
                                 
                                   H 
                                   ⁡ 
                                   
                                     ( 
                                     
                                       2 
                                       
                                         n 
                                         - 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                     , 
                     with 
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       H 
                       ⁡ 
                       
                         ( 
                         2 
                         ) 
                       
                     
                     = 
                     
                       [ 
                       
                         
                           
                             1 
                           
                           
                             1 
                           
                         
                         
                           
                             1 
                           
                           
                             
                               - 
                               1 
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
     The Hadamard matrix provides a way to find the training parameters w that have the smallest distance from the desired truth table. For this purpose, let us define by y the target truth table. Next, from y the modified version {tilde over (y)} may be obtained by following the transformation: 
     
       
         
           
             
               
                 
                   
                     
                       y 
                       ˜ 
                     
                     i 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 - 
                                 1 
                               
                               , 
                             
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   y 
                                   i 
                                 
                               
                               = 
                               1 
                             
                           
                         
                         
                           
                             
                               1 
                               , 
                             
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   y 
                                   i 
                                 
                               
                               = 
                               0 
                             
                           
                         
                         
                           
                             
                               0 
                               , 
                             
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   y 
                                   i 
                                 
                               
                               = 
                               
                                 - 
                                 1 
                               
                             
                           
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
     This modification is performed so that the realizable functions, as shown in Table 2, are expressed by the rows (or columns) of the Hadamard matrix. Note that the last case of y i =−1 represents an erasure, i.e. an input vector x for which there is no target value. As a final step, in order to take into account the non-linear part of the neuron function, the sign of the last entry of {tilde over (y)} is inverted. The best row i* of the Hadamard matrix is then found as i*=argmax|d|, where d=H{tilde over (y)} is a vector that shows how close is each row of H from the target vector {tilde over (y)}. Then, the optimal bias w 0  of the neuron is 0 if max(d)&gt;max(−d) and 1 otherwise. Furthermore, the weights (w 1 , w 2 , . . . w m ) of the neuron are simply given by the binary representation of the integer i*. 
     The previous methodology has the disadvantage that it requires a lot of memory, since the full Hadamard matrix needs to be constructed and it is also computationally demanding. The fast Walsh-Hadamard transform addresses both drawbacks by avoiding the construction of the Hadamard matrix and by reducing the complexity to 0 (m2 m ). 
     In summary, as shown in  FIG. 3 , the fast Walsh-Hadamard transform operates as a decoder that, given the target truth table, it provides the best training variables w and also indicates the bits where there is a decoding error, i.e. the realizable function differs from the target truth table. 
     An example of a circuit to implement a binary field neuron and perceptron will now be described. 
     The neuron activation function in Equation (3) can be implemented in hardware with AND and OR logical gates. 
       FIG. 4  shows an example of a potential implementation for M=3 inputs. 
     In the following, a neuron of M inputs with activation function given by Equation (3) will be represented with the symbol shown in  FIG. 5 . The specific value of the weights w 1 , . . . , w M  may be indicated inside the symbol, and the bias w 0  on the top of the symbol. If only the Π symbol appears, the weights are not fixed and would be found in the training. The symbols 1 M  or 0 m  inside the neuron indicate that the vector (w 1 , . . . , w M ) is the all-1 or the all-o vector, respectively. In both cases the bias is w 0 =0. 
     A small network can be built using exclusively neurons with activation function given by Equation (3) to have a circuit that implements the function given in Equation (2), i.e. a linear combination of the inputs plus a bias. This function is known as the binary perceptron. 
       FIG. 6A  shows a circuit of the binary field perceptron that implements the function in Equation (2). 
       FIG. 6B  shows how to combine three binary field neurons  601 ,  602 ,  603  to get the binary perceptron. The network has two layers with two neurons  601 ,  602  in the first layer and one neuron  603  in the second. To achieve the function in Equation (2) at the output of the network, the weights of the first neuron  601  in the first layer take the perceptron parameter values and those of the second neuron  602  all take value o. Note that this gives the product of all input variables x 1 , . . . , x m  at the output of the second neuron. The output of the first neuron  601  is connected to the first input of the second-layer neuron  603  and all the other inputs are connected to the output of the second neuron  602 . The weight multiplying the output of the first neuron  601  is 1, and those multiplying the output of the second neuron  602  are all o, except for one of them which takes value β. The value of β is chosen so that at the output of the last-layer neuron  603  the product of all input variables is cancelled. To achieve this, β takes the value 
     
       
         
           
             
               
                 
                   
                     β 
                     = 
                     
                       
                         ∑ 
                         
                           m 
                           = 
                           0 
                         
                         M 
                       
                       ⁢ 
                       
                         w 
                         m 
                       
                     
                   
                   . 
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
       FIG. 6B  shows the symbol used to represent the network shown in  FIG. 6B . 
     An example of a circuit to implement a Boolean monomial will now be described. 
     A Boolean monomial is a product of a subset of input variables x 1 , . . . , x M . An arbitrary monomial μ k  can be written as: 
     
       
         
           
             
               
                 
                   
                     
                       μ 
                       k 
                     
                     = 
                     
                       
                         ∏ 
                         
                           m 
                           = 
                           1 
                         
                         M 
                       
                       ⁢ 
                       
                         x 
                         m 
                         
                           q 
                           m 
                           k 
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
     where q m   k =1 if variable x m  appears in the monomial μ k  and o otherwise. Note that there are K=2 M  such monomials given by all possible values of q k =(q 1   k , . . . , q M   k ). 
       FIG. 7A  shows a circuit composed of M perceptrons and an output neuron that can implement any Boolean monomial. Since the perceptron can compute any linear function of its inputs, to get a monomial μ k  the parameters of each perceptron i, i=1, . . . , M are chosen to give x i  if q i   k =1 and to give 1 if q i   k =0. The weights of the last neuron are set to 0 m  so that this last neuron computes the product of the perceptron outputs only. 
       FIG. 7B  shows the symbol used in the remaining to represent the network shown in  FIG. 7A  when the coefficients of the neurons are chosen so that at the output any monomial μ k  is generated. 
     An example of a circuit to implement a Boolean function in Polynomial Algebraic Normal Form (ANF) will now be described. 
     The Algebraic Normal Form (ANF) is a Boolean expression composed of XOR operations of Boolean monomials. The ANF of a Boolean function ƒ(x) can be written as: 
       ƒ(x)=α 0 ⊕α 1 x 1 ⊕ . . . ⊕α M x M ⊕α 12 x 1 x 2 ⊕. . . ⊕α (M−1)M x (M−1 )x M ⊕ . . . ⊕α 1 . . . M x 1  . . . x M    (8)
 
     for some parameter values α 0 , . . . , α 12 . . . M  that depend on ƒ(x). 
       FIG. 8  shows a network built with the binary field neuron that can compute an ANF of degree at most M. Since any Boolean function can be written in ANF (see O&#39;Donnell R., “Analysis of boolean functions”, Cambridge University Press, 2014, June 5), this network can implement any Boolean function of M inputs, indicated at  801 . 
     The first three layers of the network are arranged so that at the output of the third layer, all possible monomials μ k , k= 1 , . . . ,  2   M  are generated. There are M (n−1)  additional monomials that generate o at their output and whose only function is to have for each neuron, from the fourth layer until the last one, an output in the previous layer that takes value o and that can thus be connected to the last input of every neuron. This allows the product term in Equation (3) to be cancelled and thus to have (from the fourth layer onwards) a network that only computes the XOR of all of its inputs to generate a unique value at the output. Thus, in order to add up all 2 M  terms and ensure that at all layers there is at least one neuron in the previous layer whose output is o, parameter n satisfies (M−1)M (n−1) &gt;2 M . 
     In this network, the first four layers have to generate the 2 M  monomials, therefore the parameters of all neurons in these layers are fixed. Similarly, from the fifth layer onwards all inputs are just added up with XOR, thus the coefficients of all neurons in these layers take value 1 and the biases are all set to o. The only free parameters are thus the weights of the neurons in the fourth layer, which should take value 1 if the monomial at their input μ k  appears in ƒ(x), and o otherwise. 
     An example of a circuit to implement a Boolean term will now be described. 
     A literal is a Boolean variable either negated ( x   i ) or non-negated (x i ), and a Boolean term is a product of literals. In particular, a term where all M variables appear is called a full term and it can be expressed as: 
     
       
         
           
             
               
                 
                   
                     
                       γ 
                       k 
                     
                     = 
                     
                       
                         ∏ 
                         
                           m 
                           = 
                           1 
                         
                         M 
                       
                       ⁢ 
                       
                         [ 
                         
                           
                             x 
                             m 
                             
                               ( 
                               
                                 
                                   q 
                                   m 
                                   k 
                                 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                           ⊕ 
                           
                             
                               ( 
                               
                                 
                                   x 
                                   m 
                                 
                                 _ 
                               
                               ) 
                             
                             
                               q 
                               m 
                               k 
                             
                           
                         
                         ] 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
     where, q m   k =1 if x m  appears non-negated in term y k , and o otherwise. Note that there are K=2 M  such terms given by all possible values of q k =(q 1   k , . . . , q M   k ). 
     The circuit with M perceptrons and one output neuron used to generate any monomial can also be used to generate any full term. To do so, each input variable x i  is assigned to one perceptron, and the weights of each perceptron are all set to o except the one of the assigned input variable, which is set to 1. If the variable appears in the term non-negated, the bias in of the corresponding perceptron is set to o, and to 1 otherwise. Lastly, the last neuron only computes the product of all outputs of the perceptrons, so its bias and all its weights are set to o. 
       FIG. 7C  shows the symbol used in the following to indicate a Boolean full term. 
     A circuit to implement a Boolean function in Disjunctive Normal Form (DNF) will now be described. 
     Any Boolean function can be written as the disjunction (OR) of full terms of its inputs. This standard expression of a Boolean function is called full Disjunctive Normal Form (DNF) and its general expression can be written as: 
       ƒ(x)=b 1 y 1 ∨ . . . ∨b K y K ,   (10)
 
     where the coefficients b k , k=1, . . . , 2 M  take value 1 if the corresponding term y k  appears in the full DNF of ƒ(x), and o otherwise. 
     To build a circuit that implements any full DNF using only the binary field neuron, it is necessary to build OR gates using this neuron exclusively. This can also be done with the circuit shown in  FIG. 7A . Consider a function that computes the OR between some of its inputs. The general expression of this function is: 
         g (x)=α 1 x 1 ∨ . . . ∨α M x M ,   (11)
 
     where α i =1 if variable x i  appears in the OR operation and o otherwise. The operation computed by g(x) is referred to below as a weighted OR. Applying De Morgan&#39;s law the function computed by g(x) can be rewritten as: 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             g 
                             ⁡ 
                             
                               ( 
                               x 
                               ) 
                             
                           
                           = 
                           
                             
                               
                                 α 
                                 1 
                               
                               ⁢ 
                               
                                 x 
                                 1 
                               
                             
                             ⩔ 
                             … 
                             ⩔ 
                             
                               
                                 α 
                                 M 
                               
                               ⁢ 
                               
                                 x 
                                 M 
                               
                             
                           
                         
                         , 
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             
                               
                                 α 
                                 1 
                               
                               ⁢ 
                               
                                 x 
                                 1 
                               
                             
                             ⩔ 
                             … 
                             ⩔ 
                             
                               
                                 α 
                                 M 
                               
                               ⁢ 
                               
                                 x 
                                 M 
                               
                             
                           
                           
                             _ 
                             _ 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             
                               
                                 
                                   α 
                                   1 
                                 
                                 ⁢ 
                                 
                                   x 
                                   1 
                                 
                               
                               _ 
                             
                             ⩓ 
                             … 
                             ⩓ 
                             
                               
                                 
                                   α 
                                   M 
                                 
                                 ⁢ 
                                 
                                   x 
                                   M 
                                 
                               
                               _ 
                             
                           
                           _ 
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                           
                             1 
                             ⊕ 
                             
                               
                                 ( 
                                 
                                   1 
                                   ⊕ 
                                   
                                     
                                       α 
                                       1 
                                     
                                     ⁢ 
                                     
                                       x 
                                       1 
                                     
                                   
                                 
                                 ) 
                               
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               … 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 ( 
                                 
                                   1 
                                   ⊕ 
                                   
                                     
                                       α 
                                       M 
                                     
                                     ⁢ 
                                     
                                       x 
                                       M 
                                     
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
     The expression in the last line of Equation (12) can be implemented by the network shown in  FIG. 7A , choosing the weights of each neuron conveniently. The symbol shown in  FIG. 9A  is used to indicate a network that computes the weighted OR of its M inputs for some choice of parameters α 1 , α M , and the symbol in  FIG. 9B  to indicate a “standard” OR operation of M input variables, or equivalently a weighted OR with α i =1, i=1, . . . , M. 
     For practical reasons, it may be more efficient to implement the OR gates in hardware directly with actual OR gates, instead of combining many neurons that require themselves many elementary Boolean gates. 
       FIG. 10  shows a network built exclusively with the binary field neuron that can compute any full DNF of M input variables. Since any Boolean function can be written in full DNF, this network can implement any Boolean function of M inputs. 
     Similarly to the network that computes any ANF, the first three layers of the network in  FIG. 10  are used to generate all 2 M  possible terms of M variables. Out of these, the terms that will compose the DNF are selected with the parameters of the weighted OR gates built with the three following layers. After these, the network is just a cascade of OR gates that computes the disjunction of all selected terms. 
     Unlike the ANF, where the number of monomials generated M n  should satisfy M n &gt;2 M +M (n−1)  to propagate the zeros, in this case, the number of monomials generated should satisfy M n &gt;2 M , since the tree structure previously generated with neurons has been replaced with OR (or weighted OR) gates. In turn, the depth of the tree has been multiplied by 3, since to have n layers of OR gates, 3n layers of neurons are required. 
       FIG. 11  shows a schematic diagram of a data processing system  1100  configured to implement the networks described above and its associated components. The system may comprise a processor  1101  and a non-volatile memory  1102 . The system may comprise more than one processor and more than one memory. The memory may store data that is executable by the processor. The processor may be configured to operate in accordance with a computer program stored in non-transitory form on a machine readable storage medium. The computer program may store instructions for causing the processor to perform its methods in the manner described herein. 
     In one particular implementation, the data processing system described above may be implemented as part of a communication terminal, such as a smartphone. The smartphone may comprise a sensor, such as a camera, from which sensed data is provided to form the network input. The terminal may be configured to perform error correction on data received over a communication link using the data processing system. The data processing system may be used for applications including image recognition, portrait mode photography, text prediction, user profiling, de-noising and camera enhancement. 
     The system may be implemented as a plurality of sub-systems, each of the sub-systems comprising a network as described in one of the embodiments above. In this arrangement, the output of the network of at least one of the sub-systems can be provided as an input to at least one of the other sub-systems&#39; networks. The connections between the plurality of sub-systems can be configured in dependence on the desired Boolean function to be implemented. 
     The approach of the present disclosure trains a “binary field” neuron and/or neural network without continuous components. This is made possible due to the particular design of the neuron. The present disclosure models the weight vector of each neuron as an error correcting code and formulates the neuron training problem as a channel decoding problem. The binary-field artificial neurons have parameters which implement an error correcting code. The methods used for decoding this type of neuron and for decoding BNNs have also been described, along with logical circuits that can implement this neuron and BNNs that are based on this type of neuron, and their corresponding implementation in virtual environments. 
     The proposed solution has numerous advantages over the prior art. 
     The approach can be implemented on artificial intelligence chipsets in a simple, standalone and modular manner, as required for mass production. 
     This solution presents minor losses in accuracy for dramatic benefits in simplicity, space, thermal properties, memory requirements, and energy consumption and can be used for federated learning, user profiling, privacy, security and optimal control. 
     The approach takes one step closer to a precise form of Boolean functions to be used, inspired by properties from the channel coding theory. 
     The applicant hereby discloses in isolation each individual feature described herein and any combination of two or more such features, to the extent that such features or combinations are capable of being carried out based on the present specification as a whole in the light of the common general knowledge of a person skilled in the art, irrespective of whether such features or combinations of features solve any problems disclosed herein, and without limitation to the scope of the claims. The applicant indicates that aspects of the present invention may consist of any such individual feature or combination of features. In view of the foregoing description it will be evident to a person skilled in the art that various modifications may be made within the scope of the invention.