# NOISE-ENHANCED CONVOLUTIONAL NEURAL NETWORKS

A learning computer system may include a data processing system and a hardware processor and may estimate parameters and states of a stochastic or uncertain system. The system may receive data from a user or other source; process the received data through layers of processing units, thereby generating processed data; apply masks or filters to the processed data using convolutional processing; process the masked or filtered data to produce one or more intermediate and output signals; compare the output signals with reference signals to generate error signals; send and process the error signals back through the layers of processing units; generate random, chaotic, fuzzy, or other numerical perturbations of the received data, the processed data, or the output signals; estimate the parameters and states of the stochastic or uncertain system using the received data, the numerical perturbations, and previous parameters and states of the stochastic or uncertain system; determine whether the generated numerical perturbations satisfy a condition; and, if the numerical perturbations satisfy the condition, inject the numerical perturbations into the estimated parameters or states, the received data, the processed data, the masked or filtered data, or the processing units.

## Latest UNIVERSITY OF SOUTHERN CALIFORNIA Patents:

- Biogas upgrading technology for power generation
- RADIOFLUORINATED GPC3-BINDING PEPTIDES FOR PET IMAGING OF HEPATOCELLULAR CARCINOMA
- Biocompatible substrate for facilitating interconnections between stem cells and target tissues and methods for implanting same
- Sub-harmonic switching power amplifier
- System and method for automated geometric shape deviation modeling for additive manufacturing

**Description**

**CROSS-REFERENCE TO RELATED APPLICATION**

This application is based upon and claims priority to U.S. provisional patent application 62/026,359, entitled “Noise-Boosted Convolutional Neural Networks for Image Processing,” filed Jul. 18, 2014, attorney docket number 094852-0031. This application is also related to U.S. patent application Ser. No. 14/802,760, entitled “Noise-Speed-Ups In Hidden Markov Models With Applications to Speech Recognition,” filed Jul. 17, 2015, attorney docket number 094852-0110. The entire content of each of these applications is incorporated herein by reference.

**BACKGROUND**

1. Technical Field

This disclosure relates to convolution neural networks for image and signal processing.

2. Description of Related Art

Convolutional Neural Networks (CNNs) are a practical way to learn and recognize images because training CNNs with backpropagation scales with training data. Backpropagation training may have only linear time complexity in the number of training samples. A CNN may convolve the input data with a set of filters. This may be roughly analogous to the use of receptive fields in the retina as in the Neocognitron network. Consider the CNN in _{X}×N_{X }where M_{X }and N_{X }are positive integers. Consider 2D filters W_{1}, . . . , W_{J }each of size M_{W}×N_{W}. The convolution of X with the filter W_{j }gives

*C*_{j}*=XW*_{j} (1)

where denotes 2D convolution. The 2D data matrix C_{j }has size (M_{X}+M_{W}−1)×(N_{X}+N_{Y}−1) with (m,n)-th entry

Pad X with zeros to define it at all points in the above double sum. Then pass the J matrices C_{1}, . . . , C_{J }element-wise through logistic sigmoid function s to give the hidden-neuron activations Z_{j}:

Suppose the network has K output neurons. A (M_{X}+M_{W}−1)×(N_{X}+N_{Y}−1) weight matrix U_{j}^{k }multiplies the j-th hidden neuron matrix Z_{j }element-wise. The soft-max or Gibbs activation of the k-th output neuron is

where ⊙ denotes the element-wise Hadamard product between two matrices. e is a vector of all 1s of length (M_{X}+M_{W}+−1)(N_{X}+N_{W}−1). The JK matrices U_{j}^{k }(j=1, . . . , J and k=1, . . . , K) are the weights of the connections between the hidden and output neurons. The next section presents the back-propagation training algorithm for a CNN.

**Back-Propagation for CNN Training**

The BP algorithm performs maximum likelihood (ML) estimation of the J convolution matrices W_{1}, . . . , W_{J }and the JK hidden-output weight matrices U_{j}^{k}. Let y denote the 1-in-K encoding vector of the target label for a given input image X. This means y_{k}=1 when k corresponds to the correct class and 0 otherwise. BP computes the cross entropy between the soft-max activations of the output neurons and the target vector y:

where Θ denotes all the parameters of the CNN—the J convolution matrices W_{1}, . . . , W_{j }and the weight matrix U. Minimizing this cross entropy is the same as minimizing the Kullback-Leibler divergence between the output soft-max activations and the target vector because the Kullback-Liebler divergence expands as

where E(Θ) is the cross entropy in (7) and H(y) is the entropy of the target y. The entropy of the target does not depend on the CNN parameters Θ. So minimizing the Kullback-Liebler divergence or the cross-entropy gives the same estimate Θ* of the CNN parameters.

Note that −E(Θ) is the log-likelihood

*L*(Θ)=log(*a*_{k}^{t})=−*E*(Θ) (8)

of the correct class label k for the given input image. So the ML estimate of Θ is

Θ*=argmax_{Θ}*L*(Θ). (9)

BP performs gradient ascent on the log-likelihood surface L(Θ) to iteratively find the ML estimate of Θ. This also holds when minimizing squared-error because BP is equivalent to ML estimation with a conditional Gaussian distribution bishop2006pattern; audhkhasi2013noise. The estimate of Θ at the (n+1)-th iteration is

Θ^{(n+1)}=Θ^{(n)}−η∇_{Λ}*E*(Λ)|_{Θ=Θ}_{(n)} (10)

where η is a positive learning rate. A forward pass in BP computes the activations of all hidden and output neurons in the CNN. Back-propagating the output neuron activation errors through the network gives the gradient of the data log-likelihood function with respect to the CNN parameters. Then gradient ascent in updates these parameters.

The hidden neuron activations in a CNN are “latent” or unseen variables for the purposes of the EM algorithm. BP here performs ML estimation of a CNN's parameters.

The EM algorithm itself is a popular iterative method for such ML estimation. The EM algorithm uses the lower-bound Q of the log-likelihood function L(Θ):

*Q*(Θ|Θ^{(n)})=*E*_{p(Z}_{1}_{, . . . , Z}_{j}_{|X,y,Θ}_{(n)}_{)}{log *p*(*Z*_{1}*, . . . , Z*_{J}*,y|X*,Θ)} (11)

The J matrices Z_{1}, . . . Z_{J }are the latent variables in the algorithm's expectation (E) step. Then the Maximization (M) step maximizes the Q-function to find the next parameter estimate

Θ^{(n+1)}=argmax_{Θ}*Q*(Θ|Θ^{(n)}). (12)

The generalized EM (GEM) algorithm performs this optimization by stochastic gradient ascent. Theorem 1 below states that BP is a special case of the GEM algorithm. This key theorem and its proof is restated for completeness.

**Theorem 1 Backpropagation is a Special Case of the GEM Algorithm**

The backpropagation update equation for a differentiable likelihood function p(y|x,Θ) at epoch n

Θ^{(n+1)}=Θ^{(n)}+η∇_{Θ} log *p*(*y|x*,Θ)|_{Θ=Θ}_{(n)} (13)

equals the GEM update equation at epoch n

Θ^{(n+1)}=Θ^{(n)+η∇}_{Θ}*Q*(Θ|Θ^{(n)})|_{Θ=Θ}_{(n)} (14)

where GEM uses the differentiable Q-function Q(Θ|Θ^{(n)}) in (11).

This BP-EM equivalency theorem lets the noisy EM algorithm be used to speed up the BP training of a CNN. The next section details the noisy EM algorithm. A fundamental computational problem of BP training is that it can be slow. Processing images may only exacerbate this computational burden. There have been a few ad hoc attempts to improve BP training, but no fundamental methods for speeding up BP training.

**SUMMARY**

A learning computer system may include a data processing system and a hardware processor and may estimate parameters and states of a stochastic or uncertain system. The system may receive data from a user or other source; process the received data through layers of processing units, thereby generating processed data; apply masks or filters to the processed data using convolutional processing; process the masked or filtered data to produce one or more intermediate and output signals; compare the output signals with reference signals to generate error signals; send and process the error signals back through the layers of processing units; generate random, chaotic, fuzzy, or other numerical perturbations of the received data, the processed data, or the output signals; estimate the parameters and states of the stochastic or uncertain system using the received data, the numerical perturbations, and previous parameters and states of the stochastic or uncertain system; determine whether the generated numerical perturbations satisfy a condition; and, if the numerical perturbations satisfy the condition, inject the numerical perturbations into the estimated parameters or states, the received data, the processed data, the masked or filtered data, or the processing units.

The learning computer system may unconditionally inject noise or chaotic or other perturbations into the estimated parameters or states, the received data, the processed data, the masked or filtered data, or the processing units.

The unconditional injection may speed up learning by the learning computer system and/or improve the accuracy of the learning computer system.

The received data may represent an image.

A learning computer system may include a data processing system and a hardware processor and may estimate parameters and states of a stochastic or uncertain system. The system may receive data from a user or other source; process only a portion of the received data through layers of processing units, thereby generating processed data; process the masked or filtered data to produce one or more intermediate and output signals; compare the output signals with reference signals to generate error signals; send and process the error signals back through the layers of processing units; generate random, chaotic, fuzzy, or other numerical perturbations of the portion of the received data, the processed data, or the output signals; estimate the parameters and states of the stochastic or uncertain system using the portion of the received data, the numerical perturbations, and previous parameters and states of the stochastic or uncertain system; determine whether the generated numerical perturbations satisfy a condition; and, if the numerical perturbations satisfy the condition, inject the numerical perturbations into the estimated parameters or states, the portion of the received data, the processed data, the masked or filtered data, or the processing units.

A non-transitory, tangible, computer-readable storage medium may contain a program of instructions that may cause a computer learning system comprising a data processing system that may include a hardware processor running the program of instructions to estimate parameters and states of a stochastic or uncertain system by performing one or more of the functions described herein for the computer learning system.

These, as well as other components, steps, features, objects, benefits, and advantages, will now become clear from a review of the following detailed description of illustrative embodiments, the accompanying drawings, and the claims.

**BRIEF DESCRIPTION OF DRAWINGS**

The drawings are of illustrative embodiments. They do not illustrate all embodiments. Other embodiments may be used in addition or instead. Details that may be apparent or unnecessary may be omitted to save space or for more effective illustration. Some embodiments may be practiced with additional components or steps and/or without all of the components or steps that are illustrated. When the same numeral appears in different drawings, it refers to the same or like components or steps.

**DETAILED DESCRIPTION OF ILLUSTRATIVE EMBODIMENTS**

Illustrative embodiments are now described. Other embodiments may be used in addition or instead. Details that may be apparent or unnecessary may be omitted to save space or for a more effective presentation. Some embodiments may be practiced with additional components or steps and/or without all of the components or steps that are described.

Injecting carefully chosen noise can speed convergence in the backpropagation training of a convolutional neural network (CNN). The Noisy CNN algorithm may speed up training on average because the backpropagation algorithm turns out to be a special case of the expectation-maximization (EM) algorithm and because such noise may speed up the EM algorithm on average. The CNN framework may give a practical way to learn and recognize images because backpropagation scales with training data. It may have only linear time complexity in the number of training samples. The Noisy CNN algorithm may find a separating hyperplane in the network's noise space. The hyperplane may arise from the noise-benefit condition that boosts the EM algorithm. The hyperplane may cut through a uniform-noise hypercube or Gaussian ball in the noise space depending on the type of noise used. Noise chosen from above the hyperplane may speed the training algorithm on average. Noise chosen from below may slow it. The algorithm may inject noise anywhere in the multilayered network. Adding noise to the output neurons reduced the average per-iteration training-set cross entropy by 39% on a standard MNIST image test set of handwritten digits. It also reduced the average per-iteration training-set classification error by 47%. Adding noise to the hidden layers can also reduce these performance measures. The noise benefit may be most pronounced for smaller data sets because the largest EM hill-climbing gains may tend to occur in the first few iterations. This noise effect can also assist random sampling from large data sets because it may allow a smaller random sample to give the same or better performance than a noiseless sample gives.

A noisy convolutional neural network (NCNN) algorithm for speeding up the backpropagation (BP) training of convolutional neural networks (CNNs) is now presented.

_{1}, W_{2}, and W_{3}. These masks act as receptive fields in the retina. The resulting images pass pixel-wise through logistic sigmoid functions that give the hidden neuron activations. Then, the CNN computes element-wise Hadamard products between the hidden neuron activation matrices Z_{1}, Z_{2}, and Z_{3 }with weight matrices U_{j}^{k }where j=1, 2, 3 and k=1, 2, 3. The soft-max Gibbs signal function gives the activations of the output layer neurons.

The NCNN algorithm may exploit two theoretical results. The first result is that the BP algorithm may be a special case of the generalized expectation-maximization (EM) algorithm for iteratively maximizing a likelihood. This result is restated and proving below as Theorem 1.

BP that minimizes training-sample squared error equally maximizes a likelihood in the form of the exponential of the negative squared error. Better results were achieved with BP that minimized the more common training-set cross entropy. Minimizing this performance measure is equivalent to maximizing a likelihood. Below is shown that minimizing cross entropy here may also be equivalent to minimizing the Kullback-Liebler divergence.

The second theoretical result is that carefully chosen and injected noise may speed up the EM algorithm on average as the algorithm iteratively climbs the nearest hill of likelihood. This result is stated below as Theorem 1. Below also shows that this guaranteed EM noise-boost may give rise to a simple noise-space hyperplane condition for training CNNs with backpropagation: Noise chosen from above the hyperplane may speed CNN training on average. Noise chosen from below may slow it.

This noise-hyperplane result may explain anecdotal reports that randomly chosen noise sometimes gives a slight boost in training performance. On average, such blind noise should contain roughly the same number of noise samples from above as from below the crucial NCNN hyperplane.

The NCNN algorithm may also be useful for big data applications. There may be at least two reasons for this.

The first reason is that training with BP may scale only linearly with sample size. Training BP with n samples incurs only linear O(n) time complexity. Linear complexity holds because the forward or predictive pass of BP has only O(1) complexity. The more involved backward pass has O(n) complexity. BP's overall linear complexity contrasts with the O(n^{2}) time complexity of modern support-vector kernel methods kung2014kernel. The quadratic complexity of such kernel methods arises from the O(n) complexity of their predictive pass. The recent Fastfood kernel algorithm reduces the O(n^{2}) kernel complexity to O(n log d) for n nonlinear basis functions in d dimensions. Fastfood's log linear complexity appears to be the current lower bound for kernel methods.

The second reason is that noise-boosting enhances sampling from big-data data sets. A natural way to deal with ever bigger data sets is to randomly sample from them and thus throw away or ignore some or even much of the data. Sufficiently large sample sizes can give adequate statistical precision in many cases. The laws of large numbers ensure this when using sample means and variances or covariances. This opens the door to an array of Monte Carlo sampling techniques. Some big-data “sketching” algorithms already use some form of sampling.

The NCNN algorithm allows the user to take a smaller random sample than in the noiseless case for a given level of performance or take the same number of samples for a better level of performance.

^{t }and the true target vector (0,0,1) propagates back through the CNN to compute the gradient of the cross entropy. Then gradient descent updates the weights of the CNN.

The NCNN algorithm was tested on standard MNIST test images for image recognition. The test images were handwritten digits from zero to nine. A substantial reduction in training time was found when compared with ordinary or noiseless backpropagation: NCNN reduced the average per-iteration training-set cross entropy by 39%.

These simulations achieved this noise boost by adding noise only to the output neurons. The general algorithm presented below allows the user to add noise to any of the neurons in the multilayered network. Adding noise to hidden or throughput neurons entails only slightly increased cost in terms of using a new scaling matrix and further speeds up BP training.

The hyperplane structure implies that the NCNN involves only a simple linear condition on the noise. The three dimensions of the noise space in this example correspond to the three output neurons in

Noise above the hyperplane speeds BP training convergence on average because it is just the noise that increases the iterative likelihood steps in the corresponding EM algorithm. Noise below the hyperplane slows BP convergence on average because it decreases the EM's likelihood steps compared with the noiseless case. The noise benefit will gradually shrink as the sample size increases. This means in effect that the noise boxes or balls will shrink as the noise boost becomes fainter.

**Noisy Expectation-Maximization (NEM) Algorithm**

The Noisy Expectation-Maximization (NEM) algorithm (“The Noisy Expectation-Maximization Algorithm,” Osonde Osoba, Sanya Mitaim, and Bart Kosko, *Fluctuation and Noise Letters*, vol. 12, no. 3, 1350012-1-1350012-30, September 2013) provably speeds up the EM algorithm on average. It adds noise to the data at each EM iteration. The noise decays with the iteration count to ensure convergence to the optimal parameters of the original data model. The additive noise must also satisfy the NEM condition below that ensures that the NEM parameter estimates will climb faster up the likelihood surface on average.

**NEM Theorem**

The NEM Theorem states when noise speeds up the EM algorithm's convergence to a local optimum of the likelihood surface. The NEM Theorem uses the following notation. The noise random variable N has probability density function (pdf) p(n|x). So the noise N can depend on the data x. Vector h denotes the latent or hidden variables in the model. {Θ^{(n)}} is a sequence of EM estimates for Θ.

is the converged EM estimate for Θ. Define the noisy Q function as the expectation Q_{N}(θ|θ)^{(n)}=E_{h,x,Θ}_{K }[In p(x+N,h|θ]. Assume that the differential entropy of all random variables is finite and that the additive noise keeps the data in the support of the likelihood function. Then, the general NEM theorem may be stated as (“The Noisy Expectation-Maximization Algorithm,” with Osonde Osoba, Sanya Mitaim, and Bart Kosko, Fluctuation and Noise Letters, vol. 12, no. 3, 1350012-1-1350012-30, September, 2013) Theorem 2 Noisy Expectation Maximization (NEM)

The EM estimation noise benefit

*Q*(Θ_{*}|Θ_{*})−*Q*(Θ^{(n)}|Θ_{*})≧*Q*(Θ_{*}|Θ_{*})−*Q*_{N}(Θ^{(n)}|Θ_{*}) (15)

or equivalently

*Q*_{N}(Θ^{(n)}|Θ_{*})≧*Q*(Θ^{(n)|Θ}_{*}) (16)

holds on average if an average positivity condition holds.

Reversing the inequalities in the NEM Theorem gives a dual theorem for noise harm on average. Injecting noise from below the hyperplane in

**Corollary 1 Noise Harm in Expectation Maximization**

The EM estimation noise harm

*Q*(Θ_{*}|Θ_{*})−*Q*(Θ^{(n)}|Θ_{*})≦*Q*(Θ_{*}|Θ_{*})−*Q*_{N}(Θ^{(n)}|Θ_{*}) (17)

or equivalently

*Q*_{N}(Θ^{(n)}|Θ_{*})≦*Q*(Θ^{(n)|Θ}_{*}) (18)

holds on average if the nonnegative expectation (of the logarithm of a ratio of conditional probability) holds in the NEM Theorem.

The NEM Theorem states that each iteration of a properly noisy EM algorithm gives higher likelihood estimates on average than do the regular or noiseless EM estimates. So the NEM algorithm converges faster than EM for a given data model. The faster NEM convergence occurs both because the likelihood function has an upper bound and because the NEM algorithm takes larger average steps up the likelihood surface. NEM also speeds up the training of hidden Markov models and the K-means clustering algorithm used in big-data processing. The NEM positivity condition has a much simpler form in the practical case of a Gaussian or Cauchy mixture model because then the condition reduces to a quadratic inequality.

**Noisy Backpropagation for CNN Training**

The next theorem states the noise-benefit sufficient condition for Gibbs-activation output neurons used in CNN K-class classification. Such beneficial noise is added only to the 1-in-K encoding vector y of the target class labels. The end of this section shows how to add NEM noise to the hidden neurons as well. Theorem 3 Forbidden Hyperplane Noise-Benefit Condition for CNN

The NEM positivity condition holds for ML training of a CNN with Gibbs activation output neurons if

*E*_{Y,Z}_{1}_{, . . . , Z}_{J}_{,n|X,Θ}_{*}*{n*^{T }log(*a*^{t})}≧0 (19)

where the activation of the k-th output neuron is

where ⊙ denotes the element-wise Hadamard product between two matrices. e is a vector of all 1s of length (M_{X}+M_{W}−1)(N_{X}+N_{W}−1).

^{T }log(a^{t})=0} speeds CNN training on average.

A similar noise benefit result also holds for noise injection into the hidden neurons in a CNN. The hidden neuron activations become visible data during the forward pass of neural network training and behave as output neurons for earlier layers. Then the noise benefit condition becomes (U^{T}n)^{T }log(a^{t})≧0 where U is the synaptic weight matrix that connects the hidden and output layer and where a^{t }is the vector of hidden-layer activations. This permits adding NEM noise to the hidden neurons.

Corollary 2 states a dual noise-harm result akin to Corollary. It follows from reversing the inequalities in Theorem 3 and its proof.

Corollary 2

The NEM negativity condition holds for ML training of a CNN with Gibbs activation output neurons if

*E*_{Y,Z}_{1}_{, . . . , Z}_{J}_{,n|X,Θ}_{*}*{n*^{T }log(*a*^{t})}≧0 (21)

where the activation of the k-th output neuron is given in (**20**).

**Simulation Results**

All simulations used the MNIST data set of handwritten digits. The MNIST data set contains 28×28 gray-scale pixel images with pixel intensities between 0 and 1.

The simulations used at least 1000 images from the MNIST training set. An open-source Matlab toolbox was modified to add noise during CNN training. The CNN contained one convolution layer with three 3×3 pixel masks each. The convolution layer was followed with factor-2 down-sampling to increase system robustness and to reduce the number of CNN parameters lecun1998gradient. A full non-convolution connection matrix U connected the neurons of the hidden layer to the output layer.

The output-layer neurons used the soft-max or Gibbs activation function for 10-way classification. All hidden neurons used the logistic sigmoid function. Uniform noise was used over (−0.5√{square root over (c/t^{d})},0.5√{square root over (c/t^{d})}) where c=0, 0.2, . . . , 3, d=1, 2, . . . , 5, and t was the training epoch. So the noise variance decreased to 0 as training epochs proceed.

The relative average reduction in cross entropy for NEM-BP was next plotted as the noise scale c varied from 0 to 3 in steps of 0.2.

How the training-data set size affects NEM performance was also explored. The MNIST training-set size was varied over 1000, 2000, . . . , 5000 and computed the relative average reduction in training cross entropy for NEM-BP using the optimal noise variance. T

^{5})},0.5/√{square root over (t^{5})}] where t was the training iteration number for both NEM noise and blind noise.

^{5})},0.5/√{square root over (t^{5})}] where t was the training iteration number for both NEM noise and blind noise

^{d})},0.5√{square root over (c/t^{d})}) noise was added where c=0, 0.2, . . . , 2.8, 3, t was the training epoch, and d=5 was the noise annealing factor. The noise benefit increased when c increased from 0 to 1 and tended to decrease for values greater than 1. The optimal noise scale was c*=1. Injecting NEM noise hurt the training-set cross entropy when c≧2.6.

How the NCNN algorithm favors subset sampling with CNN image recognition was also simulated.

The simulations first trained the CNN on a random selection of 1000 MNIST sample images from the full 60000 sample training set. 20 separate training runs were run at the same sample size and recorded the final squared error on the test set for each run. The next step repeated the same simulation setup but with 5% fewer samples for training. The experiment was repeated reducing the training set by 5% on each simulation epoch.

The simulation ended with the 500-sample training-set case. The dashed curve in

**SUMMARY**

Careful noise injection speeds up the backpropagation training of a convolutional neural network (CNN). This result follows because the BP algorithm is a special case of the generalized EM algorithm and because the recent noisy EM theorem gives a sufficient condition for noise to speed up the average convergence of the EM algorithm. The Noisy CNN (NCNN) algorithm uses this noisy-EM result to produce a hyperplane in noise space that separates helpful noise from harmful noise. NCNN noise-injection experiments on the MNIST image data set show substantial reduction in training-set cross entropy and in classification error rate as compared with the noiseless BP algorithm. Blind noise gave at best a small noise benefit. Simulations show that the NEM noise benefit was largest for smaller data sets. This suggests exploiting these noise benefits in random sampling from large data sets. Noise injection in different combinations of hidden layers in deep networks may also be utilized.

**101** that estimates unknown parameters and states of a stochastic or uncertain system. The learning computer system is configured to implement the various algorithms that have been discussed herein. The learning computer system may include a data processing system **103**, which may include one or more hardware processors **105**. The learning computer system may also include one or more tangible memories (e.g., random access memories (RAMs), read-only memories (ROMs), and/or programmable read only memories (PROMS)), tangible storage devices (e.g., hard disk drives, CD/DVD drives, and/or flash memories), system buses, video processing components, network communication components, input/output ports, and/or user interface devices (e.g., keyboards, pointing devices, displays, microphones, sound reproduction systems, and/or touch screens).

The learning computer system may include one or more computers at the same or different locations. When at different locations, the computers may be configured to communicate with one another through a wired and/or wireless network communication system.

The learning computer system may include software (e.g., one or more operating systems, device drivers, application programs, and/or communication programs). When software is included, the software includes programming instructions and may include associated data and libraries. When included, the programming instructions are configured to implement one or more algorithms that implement one or more of the functions of the computer system, as recited herein. The description of each function that is performed by each computer system also constitutes a description of the algorithm(s) that performs that function.

The software may be stored on or in one or more non-transitory, tangible storage devices, such as one or more hard disk drives, CDs, DVDs, and/or flash memories. The software may be in source code and/or object code format. Associated data may be stored in any type of volatile and/or non-volatile memory. The software may be loaded into a non-transitory memory and executed by one or more processors.

The components, steps, features, objects, benefits, and advantages that have been discussed are merely illustrative. None of them, nor the discussions relating to them, are intended to limit the scope of protection in any way. Numerous other embodiments are also contemplated. These include embodiments that have fewer, additional, and/or different components, steps, features, objects, benefits, and/or advantages. These also include embodiments in which the components and/or steps are arranged and/or ordered differently.

For example, the injected perturbations can be based on noise, or chaos, or fuzz, or uncertain random variables. The injection itself need not be additive. It can also be multiplicative or have any functional form. The perturbations that boost the random sampling of training samples can exploit bootstrapping and general forms of Monte Carlo sampling.

Unless otherwise stated, all measurements, values, ratings, positions, magnitudes, sizes, and other specifications that are set forth in this specification, including in the claims that follow, are approximate, not exact. They are intended to have a reasonable range that is consistent with the functions to which they relate and with what is customary in the art to which they pertain.

All articles, patents, patent applications, and other publications that have been cited in this disclosure are incorporated herein by reference.

The phrase “means for” when used in a claim is intended to and should be interpreted to embrace the corresponding structures and materials that have been described and their equivalents. Similarly, the phrase “step for” when used in a claim is intended to and should be interpreted to embrace the corresponding acts that have been described and their equivalents. The absence of these phrases from a claim means that the claim is not intended to and should not be interpreted to be limited to these corresponding structures, materials, or acts, or to their equivalents.

The scope of protection is limited solely by the claims that now follow. That scope is intended and should be interpreted to be as broad as is consistent with the ordinary meaning of the language that is used in the claims when interpreted in light of this specification and the prosecution history that follows, except where specific meanings have been set forth, and to encompass all structural and functional equivalents.

Relational terms such as “first” and “second” and the like may be used solely to distinguish one entity or action from another, without necessarily requiring or implying any actual relationship or order between them. The terms “comprises,” “comprising,” and any other variation thereof when used in connection with a list of elements in the specification or claims are intended to indicate that the list is not exclusive and that other elements may be included. Similarly, an element preceded by an “a” or an “an” does not, without further constraints, preclude the existence of additional elements of the identical type.

None of the claims are intended to embrace subject matter that fails to satisfy the requirement of Sections **101**, **102**, or **103** of the Patent Act, nor should they be interpreted in such a way. Any unintended coverage of such subject matter is hereby disclaimed. Except as just stated in this paragraph, nothing that has been stated or illustrated is intended or should be interpreted to cause a dedication of any component, step, feature, object, benefit, advantage, or equivalent to the public, regardless of whether it is or is not recited in the claims.

The abstract is provided to help the reader quickly ascertain the nature of the technical disclosure. It is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, various features in the foregoing detailed description are grouped together in various embodiments to streamline the disclosure. This method of disclosure should not be interpreted as requiring claimed embodiments to require more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter lies in less than all features of a single disclosed embodiment. Thus, the following claims are hereby incorporated into the detailed description, with each claim standing on its own as separately claimed subject matter.

## Claims

1. A learning computer system that estimates parameters and states of a stochastic or uncertain system comprising a data processing system that includes a hardware processor that has a configuration that:

- receives data from a user or other source;

- processes the received data through layers of processing units, thereby generating processed data;

- applies masks or filters to the processed data using convolutional processing;

- processes the masked or filtered data to produce one or more intermediate and output signals;

- compares the output signals with reference signals to generate error signals;

- sends and processes the error signals back through the layers of processing units;

- generates random, chaotic, fuzzy, or other numerical perturbations of the received data, the processed data, or the output signals;

- estimates the parameters and states of the stochastic or uncertain system using the received data, the numerical perturbations, and previous parameters and states of the stochastic or uncertain system;

- determines whether the generated numerical perturbations satisfy a condition; and

- if the numerical perturbations satisfy the condition, injects the numerical perturbations into the estimated parameters or states, the received data, the processed data, the masked or filtered data, or the processing units.

2. The learning computer system of claim 1 wherein the learning computer system unconditionally injects noise or chaotic or other perturbations into the estimated parameters or states, the received data, the processed data, the masked or filtered data, or the processing units.

3. The learning computer system of claim 2 wherein the unconditional injection speeds up learning by the learning computer system.

4. The learning computer system of claim 2 wherein the unconditional injection improves the accuracy of the learning computer system.

5. The learning computer system of claim 1 wherein the received data represents an image.

6. The learning computer system of claim 1 wherein the injection speeds up learning by the learning computer system.

7. The learning computer system of claim 1 wherein the injection improves the accuracy of the learning computer system.

8. A learning computer system that estimates parameters and states of a stochastic or uncertain system comprising a data processing system that includes a hardware processor that has a configuration that:

- receives data from a user or other source;

- processes only a portion of the received data through layers of processing units, thereby generating processed data;

- processes the masked or filtered data to produce one or more intermediate and output signals;

- compares the output signals with reference signals to generate error signals;

- sends and processes the error signals back through the layers of processing units;

- generates random, chaotic, fuzzy, or other numerical perturbations of the portion of the received data, the processed data, or the output signals;

- estimates the parameters and states of the stochastic or uncertain system using the portion of the received data, the numerical perturbations, and previous parameters and states of the stochastic or uncertain system;

- determines whether the generated numerical perturbations satisfy a condition; and

- if the numerical perturbations satisfy the condition, injects the numerical perturbations into the estimated parameters or states, the portion of the received data, the processed data, the masked or filtered data, or the processing units.

9. The learning computer system of claim 8 wherein the system applies masks or filters to the processed data using convolutional processing.

10. The learning computer system of claim 8 wherein the injection speeds up learning by the learning computer system.

11. The learning computer system of claim 8 wherein the injection improves the accuracy of the learning computer system.

12. The learning computer system of claim 8 wherein the system injects the random, chaotic, fuzzy, or other numerical perturbations into the portion of the received data.

13. The learning computer system of claim 8 wherein the learning computer system unconditionally injects noise or chaotic or other perturbations into the estimated parameters or states, the portion of the received data, the processed data, the masked or filtered data, or the processing units.

14. The learning computer system of claim 8 wherein the unconditional injection speeds up learning by the learning computer system.

15. The learning computer system of claim 8 wherein the unconditional injection improves the accuracy of the learning computer system.

16. A non-transitory, tangible, computer-readable storage medium containing a program of instructions that causes a computer learning system comprising a data processing system that includes a hardware processor running the program of instructions to estimate parameters and states of a stochastic or uncertain system by:

- receiving data from a user or other source;

- processing the received data through layers of processing units, thereby generating processed data;

- applying masks or filters to the processed data using convolutional processing;

- processing the masked or filtered data to produce one or more intermediate and output signals;

- comparing the output signals with reference signals to generate error signals;

- sending and processing the error signals back through the layers of processing units;

- generating random, chaotic, fuzzy, or other numerical perturbations of the received data, the processed data, or the output signals;

- estimating the parameters and states of the stochastic or uncertain system using the received data, the numerical perturbations, and previous parameters and states of the stochastic or uncertain system;

- determining whether the generated numerical perturbations satisfy a condition; and

- if the numerical perturbations satisfy the condition, injecting the numerical perturbations into the estimated parameters or states, the received data, the processed data, the masked or filtered data, or the processing units.

17. The storage medium of claim 16 wherein the program of instructions causes the computer learning system to unconditionally inject noise or chaotic or other perturbations into the estimated parameters or states, the received data, the processed data, the masked or filtered data, or the processing units.

18. The storage medium of claim 17 wherein the unconditional injection speeds up learning by the learning computer system.

19. The storage medium of claim 17 wherein the unconditional injection improves the accuracy of the learning computer system.

20. The storage medium of claim 16 wherein the received data represents an image.

21. The storage medium of claim 16 wherein the injection speeds up learning by the learning computer system.

22. The storage medium of claim 16 wherein the injection improves the accuracy of the learning computer system.

23. A non-transitory, tangible, computer-readable storage medium containing a program of instructions that causes a computer learning system comprising a data processing system that includes a hardware processor running the program of instructions to estimate parameters and states of a stochastic or uncertain system by:

- receiving data from a user or other source;

- processing only a portion of the received data through layers of processing units, thereby generating processed data;

- processing the masked or filtered data to produce one or more intermediate and output signals;

- comparing the output signals with reference signals to generate error signals;

- sending and processing the error signals back through the layers of processing units;

- generating random, chaotic, fuzzy, or other numerical perturbations of the portion of the received data, the processed data, or the output signals;

- estimating the parameters and states of the stochastic or uncertain system using the portion of the received data, the numerical perturbations, and previous parameters and states of the stochastic or uncertain system; and

- determining whether the generated numerical perturbations satisfy a condition;

- if the numerical perturbations satisfy the condition, injecting the numerical perturbations into the estimated parameters or states, the portion of the received data, the processed data, the masked or filtered data, or the processing units.

24. The storage medium of claim 23 wherein the program of instructions causes the computer learning system to apply masks or filters to the processed data using convolutional processing.

25. The storage medium of claim 23 wherein the injection speeds up learning by the learning computer system.

26. The storage medium of claim 23 wherein the injection improves the accuracy of the learning computer system.

27. The storage medium of claim 23 wherein the program of instructions causes the computer learning system to inject the random, chaotic, fuzzy, or other numerical perturbations into the portion of the received data.

28. The storage medium of claim 23 wherein the program of instructions causes the computer learning system to to unconditionally inject noise or chaotic or other perturbations into the estimated parameters or states, the portion of the received data, the processed data, the masked or filtered data, or the processing units.

29. The storage medium of claim 23 wherein the unconditional injection speeds up learning by the learning computer system.

30. The storage medium of claim 23 wherein the unconditional injection improves the accuracy of the learning computer system.

**Patent History**

**Publication number**: 20160019459

**Type:**Application

**Filed**: Jul 20, 2015

**Publication Date**: Jan 21, 2016

**Applicant**: UNIVERSITY OF SOUTHERN CALIFORNIA (Los Angeles, CA)

**Inventors**: Kartik Audhkhasi (White Plains, NY), Bart Kosko (Hacienda Heights, CA), Osonde Osoba (Los Angeles, CA)

**Application Number**: 14/803,797

**Classifications**

**International Classification**: G06N 3/08 (20060101); G06N 3/04 (20060101);