Abstract:
A method and apparatus for designing a multilayer feed forward neural network that produces a design having a minimum number of connecting weights is based on a novel iterative procedure for inverting the full Hessian matrix of the neural network. The inversion of the full Hessian matrix results in a practical strategy for pruning weights of a trained neural network. The error caused by pruning is minimized by a correction that is applied to remaining (un-pruned) weights thus reducing the need for retraining. However, retraining may be applied to the network possibly leading to further the simplification of the network design.

Description:
This is a divisional of application Ser. No. 08/297,702, filed Aug. 29, 1994, now abandoned, which is a continuation of application Ser. No. 07/940,681, filed Sep. 4, 1992, now abandoned. 
    
    
     FIELD OF THE INVENTION 
     The present invention relates to the manufacture and design of multilayer artificial neural networks and more specifically to the design and manufacture of networks with a reduced number of interconnections resulting in improved generalizing characteristics and minimal increase in training error. 
     BACKGROUND OF THE INVENTION 
     Artificial neural networks (ANNs) are typically designed and constructed as a multilayer structure having one or more hidden layers of artificial neurons (ANs) and an output layer of ANs as shown in FIG. 1. Most commonly, each layer consists of a number of ANs and each AN comprises a node and a group of weighted input receptors or synapses. The weighted receptors couple the output of lower level ANs to the nodes of the next higher layer through a weighting element that modifies the amplitude of the input signal to the receptor. The node sums the weighted receptor inputs and applies the sum to a monotonically increasing nonlinear element that produces the output signal of the node. Thus, the number of weighted receptors in any given layer may be equal to the product of the number of ANs (or nodes) and the number of nodes in the next lower layer. The total number of weighting elements may be as large as KN 2 , where K is the number of layers and N is the average number of nodes per layer. A modest ANN that accommodates an input vector with 100 component signals could have as many as 10,000 weighting elements per layer. This would not be an excessively large network compared to networks reported to have 6.5×10 6  weights with 2600 input parameters. A central problem in the design of neural networks is minimizing the complexity of the network so that the resulting ANN complexity is consistent with the training data available. Complexity management translates into minimizing the number of weights. It is well-known that without such network &#34;pruning&#34; a mismatch between the number weights used in the network and the &#34;degrees of freedom&#34; (complexity) will result in sub-optimal performance. Having too many weights (high complexity) leads to overfitting and hence poor generalization. Conversely, if too few weights are used (insufficient complexity), the network&#39;s ability to learn will be impaired. Generalization is optimized by trading off network complexity and training error. Unfortunately, no simple method for determining the required degree of complexity, prior to a trial training session, is available. 
     Consequently, even when an ANN is trained and found to function adequately on the available training data, it is not apparent that the complexity of the ANN is commensurate with the objective. Elimination of weights and/or ANs and retraining suggests itself. However, it is not clear how such pruning is to be done. In other words an efficient rational pruning method is needed as a guide to reducing the complexity of a trained ANN. 
     Hertz et al. have proposed a pruning method based on removing weights having the smallest magnitude (Hertz, J. Krogh, A., and Palmer, R. G. &#34;Introduction to the theory of Neural Computation,&#34; Addison Wesley 1991). This idea unfortunately often leads to the elimination of the wrong weights in high order ANNs because the combined affect of low magnitude weights may be essential for low error. 
     A method for reducing ANN size by selectively deleting weights that is applicable to large scale networks has been described by LeCun et al. (LeCun, Y., Decker, J. S., and Solla, S. A., (1990) &#34;Optimal Brain Damage&#34;, Neural Information Processing Systems, Vol. 2, Touretzky, D. S. (ed.) pp. 598-605, Morgan-Kaufmann). The method is based on a theoretical measure using the second derivative of the objective function with respect to the weighting parameters for computing the saliencies. Saliency is defined to be the change in objective function caused by deleting that parameter. Because it is prohibitively laborious to evaluate the saliency directly by deleting each parameter and evaluating the objective function, an analytical prediction of saliency is used based on a Taylor series expansion of the objective error function. A perturbation of the weight vector w by δw causes a perturbation in value of the error objective function or metric, E, corresponding to E+δE where ##EQU1## and δw k , an element of δw, the perturbation introduced into the weight w k  of vector w. 
     By assuming that only the diagonal terms (i=j) are significant, LeCun et al. arrive at the simplified saliency measure ##EQU2## Thus, by analytically determining the values of h ij  =∂E/∂ 2  w i , the effect of any change in weights, δw i , on the objective, δE, may be estimated from the known activation function characteristics of the ANs used, and from the topology of the ANN. 
     The simplifying assumption made by LeCun et al. may lead to sub-optimal results if the off-diagonal terms (h i ,j ; j∫i) are significant. 
     Another approach requires that statistical tests be performed on weights during training. If a weight is not &#34;statistically significant from zero,&#34; then that weight is to be eliminated or reduced in value (decayed) (Hertz et al., op. cit.). Unfortunately, the statistical tests are performed during training, and it is unclear how the statistics of the weight during training relates to the final trained network. 
     For example, a set of benchmark problems were used in a recent competition in machine learning (Thrun, S. B., and 23 co-authors (1991), &#34;The MONK&#39;s Problems--A Performance Comparison of Different Learning Algorithms&#34;, CMU-CS-91-197 Carnegie-Mellon Univ. Dept. of Comp. Science Tech, Repo.), the most successful method was back propagation using weight decay, which yielded a network with 58 weights for one MONK&#39;s problem. The method of the present invention requires only 14 weights for the same performance and on two other MONK&#39;s problems, resulted in a 62% and 90% reduction in the number of weights. 
     SUMMARY AND OBJECTS OF THE INVENTION 
     One of the objects of the present invention is to an optimal manufacturing and design method for pruning neural network weights based on a Taylor series expansion of the predicted error. 
     Another object is to provide a pruning method that does not require any restrictive assumptions on the network&#39;s Hessian matrix. 
     Another object is to provide a method for pruning and adjusting the remaining weights so that retraining is not required. 
     Another object is to provide a pruning method that results in a minimal increase in error and may result in an overall reduction in error. 
     Another object is to provide a neural network structure with a minimal set of weights based on use of the Hessian matrix. 
     Another object is to provide a manufacturing and design apparatus for manufacturing minimum complexity networks. 
     A method and apparatus for the design and manufacture of optimal neural networks featuring a minimum number of weights is based on the inversion of the full Hessian matrix of the multilayer neural network. The Hessian, which represents all of the second derivative information of the neural network, is inverted by a novel interactive method that makes it practical to invert Hessians of large dimensions. Pruning is based on the selection of minimum saliency candidate elements for elimination combined with a weight correction vector for adjusting the remaining weights without requiring retraining. A total optimally pruned neural network design and manufacture system uses a gradient training system operating cooperatively with an optimal pruning system. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The present invention is illustrated by way of example and not limitation in the figures of the accompanying drawings, in which like references indicate similar elements and in which: 
     FIG. 1 shows the topology of a multilayer artificial neural network. 
     FIG. 2 shows a typical M-P type artificial neural cell. 
     FIG. 3 illustrates an error surface and the affects of various pruning methods on residual error. 
     FIG. 4 shows a single output artificial neural network that defines the algebraic indexing. 
     FIG. 5 is a flow diagram for the optimum pruning design method. 
     FIG. 6 is a flow diagram of the optimum pruning design method including complete neuron pruning. 
     FIG. 7, showing FIGS. 7(a) and 7(b), shows the improvement in neural network design achieved by the current invention. 
     FIG. 8 is a functional block diagram of a neural network pruning design system. 
    
    
     DETAILED DESCRIPTION 
     A method for pruning and adjusting the weights of a feed-forward ANN is described that is based upon a Taylor expansion of the saliency function of the network. The method is suitable as an automated design and manufacturing system when used in conjunction with standard learning methods (such as backpropagation). It is more effective than prior art methods because it takes into consideration the interrelationships among all weights throughout the network. This consideration is important because, from FIG. 1, it is clear that the input to any artificial neuron may be effected by any or all of the weights of lower hidden layers. 
     FIG. 2 provides additional details of the commonly used individual artificial neurons of the M-P (McCullough-Pitts) type. Input data is provided on lines 17 and scaled by the synaptic weights 11 (an offset signal may also be supplied on line 12), summed by summing unit 13 producing the signal &#34;net&#34; which is applied to the sigmoidal output nonlinearity 15 producing output signal f(net). 
     Because the effects of weight changes will, in general, be coupled to other weight changes, it is reasonable to expect that any pruning strategy should account for the interactive effects. 
     In the supervised learning mode, a neural network is trained by applying a series of input data vectors to the input terminals of a network with some initial set of weights, represented by the vector, w. The output vector response of the network is then compared to a set of exemplar vector responses that correspond to the desired network response for each input vector. The error metric, E, based on the difference between the desired response and the observed response, is then used to adjust the individual weights of the weight vector, w. Typically, a gradient descent form of algorithm is used such as the well known generalized delta rule or backpropagation rule [Rumelhart, D. E., Hinton, G. E., and Williams, R. J., Learning Internal Representations by Error propagation, Chapt. 8, parallel Distributed Processing, Vol. 1, 1986, Cambridge, MIT Press]. 
     After applying a sufficient set of exemplar input and output vectors, the error reaches an apparent minimum or saddle point in the error as defined by the weight parameter space. The gradient of the error with respect to the weight vector, ΔE, is zero (approximately) ##EQU3## and 
     
         w=[w.sub.1 w.sub.2 . . . w.sub.N ].sup.T 
    
     where the superscript T denotes the vector transpose. 
     Although the gradient of the error, AE, is zero, the error metric, E, most probably will not be zero. 
     It is desired to find the saliency or sensitivity of the error metric, E, to perturbations in the component weights of the weight vector, w. This may be obtained by means of a Taylor series expansion of the perturbed error metric as follows: ##EQU4## where δE is the change in the error metric due to changes or perturbations in the weight vector, δw, H=∂ 2  E/∂w 2  is the Hessian matrix containing all second order derivative information. 
     
         δw=[δw.sub.1 δw.sub.2 . . . δw.sub.N ].sup.T(5) 
    
     Because the network is trained to an error minimum, the first term of equation (4), is the gradient, ΔE, which is zero. Also, because the perturbations are assumed to be small, the last term and all higher order terms are also assumed to be zero, resulting in the following approximation relating weight perturbations to error perturbations. 
     
         δE=1/2δw.sup.T ·H·δw   (6) 
    
     where ##EQU5## and 
     
         H.sub.ij =∂.sup.2 E/∂w.sub.i ∂w.sub.j(8) 
    
     Thus, if each of term, H ij , is evaluated, the effect of a weight vector perturbation, δw, can be predicted by equation (6). 
     Because our purpose is to prune or eliminate weights, and upon eliminating a weight to find the necessary adjustment to the remaining weights that minimizes the resulting error, suppose we eliminate weight, w q . This may be algebraically expressed as 
     
         δw.sub.q =-w.sub.q                                   (9) 
    
     or 
     
         δw.sub.q +w.sub.q =0                                 (10) 
    
     where δw q  and w q  are vector components. If e q  represents the unit vector in weight space corresponding to w q , then the vector dot product of e q  with the vector δw yields 
     
         e.sub.q.sup.T δw=-w.sub.q 
    
     or 
     
         e.sub.q.sup.T ·δw+w.sub.q =0                (11) 
    
     In order to minimize δE by eliminating the minimum weight, w q , we form a Lagrangian from equations (6) and (11) 
     
         L=1/2δw.sup.T ·H·δw+λ(e.sub.q.sup.T ·δw+w.sub.q)                               (12) 
    
     where λ is the Lagrangian undetermined multiplier. The Lagrangian, L, represents the increase in error due to eliminating w q . 
     Equation (12) has two unknowns: λ, and δw, which is the change in the weight vector w that is required to minimize the error increase, L, due to eliminating w q . The solution is obtained from equation (12) by taking the functional derivative of L and setting it to zero. ##EQU6## By means of the constraints of equation (11) and the use of matrix inversion to find the Lagrangian multiplier, we obtain 
     
         λ=-w.sub.q /[H.sup.-1 ].sub.qq                      (14) 
    
     where [H -1  ] qq  =e q   T  H -1  e q  which is the qq th  component of the inverse of matrix H. The optimal weight change and resulting error change are: 
     
         δw=-(w.sub.q /[H.sup.-1 ].sub.qq)H.sup.-1 ·e.sub.q(15) 
    
     
         L.sub.q =1/2w.sub.q.sup.2 /[H.sup.-1 ].sub.qq              (16) 
    
     Equations (16) and (15) are the desired expressions for L q , the minimum increase in error, due to setting w q  =0, and for adjusting the weight vector, w, by the error adjustment vector, δw. 
     It is important to note that the new weight vector, w+δw, is obtained without retraining of the network by the application of training data vectors and suggests three pruning strategies: 
     (1) Use w+δw as the new weight vector; 
     (2) Use w+δw as the new weight vector, retrain the network and optionally re-prune the retrained network as outlined above. 
     (3) Use w+δw as the new weight vector and repeat the pruning process outlined above until the accumulated error increase obtained by successive evaluations of equation (16) exceeds the allowable error budget and then retrain the network. 
     Because the resulting error function may not be at an exact minimum (due to higher order terms being ignored) retraining may be useful in establishing a better minimum. 
     It should also be noted that neither H nor H -1  need to be diagonal because no simplifying assumption has been made in order that the inverse, H -1 , be readily obtained from H. 
     For purposes of explanation, FIG. 3 depicts an error surface for a two weight system, w=[w 1  w 2  ] T . The error surface portrayed is general in that it has different curvatures (second derivative) along different directions and a principle axes that is not parallel to either weight axes (which implies a non-diagonal Hessian matrix). 
     It is assumed that a local minimum has been found by training, perhaps by one of the well known gradient descent methods. The minimum in the error surface is located at w 1  =α, w 2  =β, where α&gt;β, as shown in FIG. 3. If the smaller weight, w 2  =β, were to be pruned, the operating point (α,β) would move to (α, 0) as shown and the resulting error would increase corresponding to E(α, 0) which lies on the intersection of the error surface and the plane defined by the w 1  and Error axes, directly above w 1  =α. This procedure corresponds to magnitude based pruning. 
     If the pruning procedure is based on the simplifying assumption of LeCun et al., the change in weight would be made along a line parallel to the w 1 , or the w 2  axis. In the example shown in FIG. 3, ##EQU7## As a result, w 1  would be pruned because the error sensitivity (saliency), L 1 , is less than L 2 . The resulting error, E(0, β), would lie in the w 2 , E plane. For this example, the error would be less than obtained by use of weight magnitude information only. 
     If the optimal weight pruning method of this invention is used, the weight w 1  would be pruned as per LeCun et al., because it would be the least saliency defined in this invention (Eq. 16). However, because the Hessian matrix, H, was not assumed to be diagonal, equation (15) provides a correction to the value of w 2  so that the minimum error lies at (0, w 2  &#39;) where 
     
         w.sub.2 &#39;=w.sub.2 +δw.sub.2                          (17) 
    
     Noting that, for the example of FIG. 3, 
     
         δw=[δw.sub.1 δw.sub.2 ].sup.T            (18) 
    
     
         w.sub.q =w.sub.1                                           (19) 
    
     so that 
     
         e.sub.q =e.sub.1 =[1 0].sup.T                              (20) 
    
     and letting ##EQU8## substitution of the above in equation (15) obtains ##EQU9## so that 
     
         δw.sub.1 =-w.sub.1                                   (23) ##EQU10## 
    
     Thus, equation (23) restates the pruning of weight w 1 , (i.e., δw 1  +w 1  =0), while equation (24) gives the correction δw 2 , of equation (17) that must be applied to w 2 . 
     Referring back to FIG. 3, this correction is indicated by the shift, δw 2 , from E(0, w 2 ) to E(0, w 2  &#39;) by the distance -(G 21  /G 11 )w 1 . As a result, the error returns to the trough of the error surface. 
     In summary, the method described has the following major steps: 
     (1) Train the network to a minimum error using well established training procedures. 
     (2) Compute H -1  from the known ANN topology, known activating functions (output nonlinearities) and synaptic weights. 
     (3) Find the &#34;q&#34; that gives the smallest error increase as smaller than the total error, E, the q th  weight should be deleted. Otherwise go to step 5. 
     (4) Use the value of q from step 3 to update all weights by 
     
         δw=-(w.sub.q /[H.sup.-1 ].sub.qq) H.sup.-1 ·e.sub.q(15) 
    
     and return to step 2. 
     (5) Because no more weights may be deleted without a large increase in E, the process ends or the the overall cycle can be repeated by retraining the network (going to step 1). 
     FIG. 5 is a flow diagram of the design procedure &#34;A,&#34; beginning at step 400, in accordance with the above description. In step 402 the neural network is trained in accordance with anyone of the known gradient or rule-based rules, yielding a set of weights represented by the weight vector, w. From the topological, neural activation function descriptions, and the vector w, the Hessian inverse is computed in step 404. Step 406 computes the saliences of the weights and finds the weights w q  with the smallest saliency, L q . Step 408 tests to see if the resulting error from the pruning of w q , E+L q , is less than the maximum a variable error, E max . If not, the required weight vector change, δw, is calculated and a new weight vector w&#39;=w+δw is computed in step 410 and the process returns to step 404 for a new trial cycle of pruning. If the error budget is exceeded by the trial L q  in test step 408, the process proceeds to step 412 where a decision is made whether to retrain. If retraining is desired, step 416 replaces the old vector w with the latest updated vector w&#39; from step 410 and the process returns to step 402. Otherwise, the process ends at step 414. 
     The Hessian is readily computed from the known topology of the ANN, including the weight values and activation functions of each AN in the network. For example see Bishop, C., &#34;Exact Calculation of the Hessian Matrix for the Multilayer Perceptron&#34;, Neural Computation 4, 494-501 (1992). 
     The difficulty in the above outlined procedure appears to be step 2 because inverting a matrix of hundreds or thousands of terms seems computationally intractable. However, it will be shown below that for backpropagation trainable networks, the Hessian has a structure which permits its inverse to be calculated efficiently and robustly, even for large Hessian matrices. 
     In order for this procedure to be a practical pruning method, an efficient way to calculate the inverse Hessian matrix, H -1 , must be found, particularly for the very large ANNs involving thousands of weights. Otherwise, the method becomes computationally intractable. 
     In the following discussion on an efficient method for computing the inverse Hessian matrix, the standard terminology from back propagation [Rumelhart et al. op. cit.] will be used. 
     Consider the ANN of FIG. 4 in which we have an n i  component input vector indexed by 1&lt;i&lt;n i , a set of hidden layer ANs indexed by 1&lt;j&lt;n j , and connected to the input vector by synaptic weights, u ji , and an output AN connected to the hidden layer output by synaptic weights v j . (For the sake of clarity, offset inputs to each AN are not shown.) The vectors X v  and X u  refer to second derivative information as described below. 
     Using the quadratic error function of Rumelhart et al., the error, E, is given by ##EQU11## where P is the total number of training patterns, [k] is the training pattern index, t.sup.[k]  is the k th  teaching vector exemplar response, and 0.sup.[k]  is the output of the ANN due to the application of the k th  input pattern. 
     The output, 0.sup.[k], is a function of the input signal, net, supplied to the output activation function f(·), so that 
     
         0.sup.[k] =f(net.sup.[k]) 
    
     and ##EQU12## where 0 j .sup.[k]  is the j th  output of the hidden layer j th  neuron and v j  is the associated synaptic weight coupling the j th  hidden layer neuron output to the output layer neuron. 
     Thus, the first partial derivative of equation (26) with respect to the weight v j  is ##EQU13## A second partial differentiation with respect to v j , results in ##EQU14## 
     In a similar manner, two additional second partial derivatives with respect to output synaptic weights, {v j  }, and hidden layer synaptic weights, {u j  }, are obtained from equation (26): ##EQU15## where δ is the Kronecker delta and net j  is the input signal to the activation function of the j th  hidden layer neuron. 
     Because these second derivatives need only to be evaluated after training when t.sup.[k] ≈0.sup.[k], equations (27)-(29) simplify to: ##EQU16## 
     The remarkably elegant structure of equations (30)-(32) permits the calculation of the Hessian and its inverse. To see this, first define vectors containing second derivative information for the weight layers v and u (FIG. 4). ##EQU17## where for X u , lexico-graphical ordering over the input and hidden units is used. These vectors are concatenated to form a furl vector of second derivative information throughout the network (evaluated for a single pattern [k]): ##EQU18## The dimensionality of X is equal to the total number of weights in the network. The Hessian, evaluated at a local minimum, is then simply: ##EQU19## The full Hessian is calculated by sequentially adding in successive &#34;component&#34; Hessians (equation (36)) as: 
     
         H.sub.m+1 =H.sub.m +1/pX.sup.[m+1] ·X.sup.[m+1]T  (37) 
    
     with H 0  =α1 and Hp=H. The solution to equations (14)-(16) requires the inverse of H. This inverse can be calculated using a standard matrix inversion formula (Kailath, T., Linear Systems, Prentice Hall, 1980) as follows: 
     
         (A+B·C·D).sup.-1 =A.sup.-1 -A.sup.-1 ·B·(C.sup.-1 +D·A.sup.-1 ·B).sup.-1 ·D·A.sup.-1                             (38) 
    
     which applied to each term in the analogous sequence in equation (37), yields ##EQU20## with H 0   -1  =α -1  l and Hp -1  =H -1 , and where α(10 -8  ≦α≦10 -4 ) is a constant needed to make H 0   -1  meaningful, and chosen small in order to penalize large δw, thereby keeping the second order approximation of Eq. 6 valid. This inventive method is insensitive to α over a large range. 
     Equation (39) is a pivotal result, which permits the calculation of H -1  using a single sequential pass through the training data 1≦m≦p. 
     Note that the approximations used for equations (30)-(32) induce several very nice computational properties in equation (39). The first is that because of the approximation t.sup.[k] ≈0.sup.[k], H -1  is being evaluated at the desired error minimum, despite the possibility that the network has not been fully trained to this minimum. Moreover, there are no singularities in the calculation of H -1 . For large dimensional problems this method is better than first computing the Hessian, and then inverting it through standard matrix inversion techniques. Finally, equation (39) is an O(n 2 ) calculation for an nxn Hessian matrix that may admit efficient O(n) parallel implementations in VLSI. 
     The method described above was applied to three of the MONK&#39;s problems and the results compared with those of Thrun et al. cited previously. The backpropagation network with weight decay of Thrun et al. outperformed all other network and rule-based approaches on these benchmark problems in that extensive machine learning competition. 
     The following table summarizes the relative pruning effectiveness of the inventive method described on problems MONK 1, 2, and 3. Rows are identified by the method used, i.e., Thrun for Thrun et al. and HS for the present inventive method. 
     
         ______________________________________Accuracy %      NumberProblem  Training  Test   of Weights                            Pruning Method______________________________________MONK 1 100       100    58       THRUN  100       100    14       HSMONK 2 100       100    39       THRUN  100       100    15       HSMONK 3 93.4      97.2   39       THRUN  93.4      97.2    4       HS______________________________________ 
    
     For all three MONK problems, the accuracy of the current method was made the same as that of Thrun et al. by limiting the degree of pruning. The two accuracy columns, Training and Test, shows the percentage accuracy using training and test vectors, respectively. The next column clearly shows the number of weights required by each method with the current method requiring 14, 15, and 4 versus 58, 39, and 39 for the method of Thrun et al., a reduction of 76%, 62%, and 90%, respectively. 
     The algorithm described above and flow diagrammed in FIG. 5 represents the basic method for pruning weights. Other practical improvement can be made including: 
     (1) deletion of all input weights to any hidden unit whose output is rendered ineffectual by the pruning of all weights connected to its output; and 
     (2) deletion of more than one weight at a time in order to avoid the computation of H -1  after each single weight deletion. 
     The first improvement clearly removes any neuron that is not connected to higher output levels and all associated synaptic weights thereby economizing network resources without any loss in performance. 
     FIG. 6 is a flow diagram of the design method &#34;B&#34; in which pruning of entire neurons, including their associated synaptic input weights, whenever a synaptic weight, v j , of the output neuron of a single output network is pruned. The process is identical to that of FIG. 5 except that test step 520 and step 522 have been added. Upon determining that the error budget, E max , is not exceeded set 508 by the proposed pruning of w q , step 520 checks if w q  is a synaptic weight of the output layer (w q  =v j ) and if so moves to step 522 where neuron j of the hidden layer is deleted, including all of its input synaptic weights. If w q  is not an output synaptic weight, the process moves on to step 510 as in design method &#34;A.&#34; 
     The basis for the second improvement is the following generalizing of equations (15) and (16): ##EQU21## where w i1  . . . w in  are the weights corresponding to the lowest set of m saliencies, and e i1  . . . e im  are the corresponding unit vector elements. 
     In general, it may not be practical to find the smallest total saliency, L, of equation (42) over all possible combinations of i 1  to i m . However, equation (42) can be used, for the deletion of a whole hidden unit. In this case, w q  =[w q1  w q2  . . . w qm  ] T  would represent the synaptic weights connected to the hidden unit, and L q  would represent the smallest error increase over all hidden units. 
     A simple heuristic which seems to work, especially for the earliest pruning procedures is to choose i 1  . . . i m  based on the &#34;single&#34; saliencies computed by equation (16). Although this is not a rigorously valid procedure because deleting a weight would, in general, change the saliencies at the remaining weights. However, it is plausible that such saliency covariance is negligible for large networks. 
     Although the pruning design procedure described above has been restricted to a single output node, it is straight forward to generalize to a network with multiple output units. The new expression for the error (analogous to equation (26)) becomes ##EQU22## where [bk] is the training index for the b th  output node and the k th  training pattern, and the second summation is over no output nodes as shown in FIG. 1. 
     As a result, the Hessian can be written as ##EQU23## where ##EQU24## 
     This leads to the recursion relation for the Hessian: 
     
         H.sub.b+1,k =H.sub.b,k +1/PX.sup.[b+1 k] ·X.sup.[b+1 k]T H.sub.1,k+1 =H.sub.n.sbsb.0.sub.,k +1/PX.sup.[1 k+1] ·X.sup.[1 k+1]T                                                     (45) 
    
     which is analogous to equation (37) except that there is a double index on H now, and that H=H n .sbsb.0 p . 
     The inverse Hessian, H -1 , obtained as previously described, becomes: ##EQU25## which again is an iterative solution to the inverse problem that is analogous to equation (39). 
     Consequently, the design method has the same flow diagram as shown in FIG. 5. Also, FIG. 6 applies if step 520 is interpreted as a test to determine if a subset of the weights, {w q  }, corresponds to the total set of output cells synaptic weights, {v j  }, fed by the j th  hidden neuron. 
     FIG. 7 graphically demonstrates the improvement in neural network design achieved by the current invention for the MONK 1 problems previously discussed. The solid lines correspond to excitatory weights while the dotted lines correspond to inhibitory weights. The node to the left of the hidden layer of each neural net of FIG. 7 is an offset input. FIG. 7(a) shows the network topology using the Thrun et al. pruning method while FIG. 7(b) is the result of pruning by the present inventive method for equal accuracy. 
     FIG. 8 is a functional block diagram of a minimum connection neural network design apparatus 300 for use in the design process of neural network manufacturing. Its purpose is to determine a minimum set of interconnecting weights under the constraint of a given error budget. The error budget is expressed as an objective function which most commonly takes on the form of a minimum means square error between the actual output and the desired (exemption) output. The output from apparatus 300 is a design list of weights which are keyed to the topology of the neural network. All neural cells making up the neural network have prescribed activation functions (f(net)) that together with topology permit the calculation of the inverse Hessian, H -1 , the saliency, L, and the weight adjustment vector, δw. 
     The apparatus comprises a processor and control unit 280, a read/write memory 250, a memory data bus 202, an artificial neural network training unit 240, an error differencing network 256, a weight pruning unit 200, a weight adjustment adder unit 204, and a neural net model unit 220. 
     Processor and control unit 280 provides auxiliary numerical processing and overall control of the various elements of the apparatus, as indicated by control lines 52, 54, 56, and 58. (All data buses are indicated by bold interconnecting lines). Processor-control unit 280 data input/output interfaces with memory 250. Memory 250 data interface to processing units 200, 204, 240, 256, and 220 is via memory data bus 202. 
     In one embodiment, training unit 240 is a conventional gradient descent training unit using the well known backpropagation algorithm. In the training mode, training unit 240 and neural net model 220 are initialized from memory 250 via bus 202 providing initial weights, topological, and network circuit characteristics (activation functions). Training input vectors, x.sup.[k], are provided from memory 250 via bus 202 together with their exemplar responses, t.sup.[k]. Neural net model 220 simulates the network response to the input vector, x.sup.[k], providing an output 0.sup.[k]  which is compared to t.sup.[k]  by differencing unit 256 which forms at its output an error vector t.sup.[k] -0.sup.[k]  for each input/output exemplar pairs (x.sup.[k], 0.sup.[k]). Training unit 240 produces a new weight vector w, which is supplied via adder 204 to network model unit 220. (In the training mode, the output, δw, of pruning unit 200 is zero, thereby allowing the w to pass on through unmodified.) This updates the network model in unit 220 and iteratively converges the model to a minimum error operation point defined by the weights space. Once training is completed, the pruning process begins. 
     The pruning of weights is accomplished by pruning unit 200 operating cooperatively with training unit 240, adder 204, memory 250 and processor control unit 280 in accordance with the processes outlined in FIGS. 5 and 6. Pruning unit calculates H -1  using the latest topological and weight vector information provided by training unit 240 or if stored after training from memory 250. The selected pruning operation, w q , based on passing the error constraint, E max , is used to compute a weight vector correction, δw, which may include the deletion of ineffective weights as previously discussed (steps 520, 522, of FIG. 6). The correction, δw, is added to the vector w by adder 24 to obtain the updated weight vector w which is again processed by processing unit 200 temporarily stored in memory 250. 
     If the error budget, E max , is exceeded by a candidate pruning operation, the previous weight set, w&#39;, is preserved in memory 250. If retraining is deemed to be unprofitable, by actual trial or by a prior established criterion, the process ends and the updated neural network model in net model unit 20 has the necessary topology and weight value listings specifying the design may be made available to the manufacturing process steps that follow. 
     If retraining the remaining weights is required, the updated weight vector, w&#39;, has been made available after each pruning operation to the neural net model unit 220, or can be made available from memory 250 to model 220 and training unit 240. 
     Note that neural net model unit 220 may be either a real or virtual network model. If it is a virtual network, a software network simulator is used. Such simulators are used extensively in the practice of the neural network art. 
     In the foregoing specification, the invention has been described with reference to specific embodiments thereof. It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention as set forth in the appended claims. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.