Speedup from a different parametrization within the Neural Network algorithm

TL;DR

This paper introduces a new parametrization for hyperplanes in neural networks that improves training efficiency and performance, making the model easier to understand and initialize, as demonstrated on autoencoder examples.

Contribution

It proposes a novel hyperplane parametrization in neural networks that outperforms traditional methods in training speed and accuracy.

Findings

Lower training error with fewer epochs

Faster convergence compared to usual parametrization

Easier understanding and initialization of parameters

Abstract

A different parametrization of the hyperplanes is used in the neural network algorithm. As demonstrated on several autoencoder examples it significantly outperforms the usual parametrization, reaching lower training error values with only a fraction of the number of epochs. It's argued that it makes it easier to understand and initialize the parameters.

Figures

Tables

Table 1. Table 1: η 𝜂 \eta values used

$d_1$	${\eta }_z$	${\eta }_w$
8	0.180	0.45
16	0.110	0.22
32	0.040	0.12
64	0.016	0.07
128	0.010	0.06

Table 2. Table 2: Epoch speedups

$d_1$	speedup
8	6.75
16	8.5
32	7.75
64	5.1
128	5.0

Equations

$$n_2(j)$$

$$h_1(j)$$

$$f(h)$$

$$E=\sum _k[n_3(k)-t(k){]}^2$$

$$\Delta w=-\eta \frac{\partial E}{\partial w}$$

$$h$$

$$=s(c+u\cdot x)$$

$$\partial E/\partial s_2(p)$$

$$\partial E/\partial c_2(p)$$

$$\partial E/\partial u_2(p,q)$$

$$\partial E/\partial s_1(p)$$

$$\partial E/\partial c_1(p)$$

$$\partial E/\partial u_1(p,q)$$

$$A(p)$$

$$B(p)$$

$$h_v(p)$$

$$w_i\to (s/||w^{\prime }||)w_i$$

Full text

1 Introduction

Artificial Neural Networks (or Neural Nets (NN)) are a powerful and versatile machine learning algorithm. They act as a universal function approximator, and can be used in classification and regression problems[3, 1, 2]. However, despite their successes, a problem that persists is long training times of the NN. This paper addresses that problem by proposing a different parametrization of the hyperplanes used in the algorithm.

This paper demonstrates the new approach on five autoencoder examples. It allows the training to proceed much more rapidly, using in some cases only 1/8-th the number of epochs of the existing approach to reach a given training error value. Results are given for individual runs, averaged runs, and the "epoch speedup". Also, this different parametrization is more intuitive, making it easier to understand how the parameters work, and thus provides insight into how one might best initialize a NN.

2 NN definitions

Here the architecture and variables are defined for the 3-layer NN that will be used in the examples. It is a feed-forward NN with $d_{1}$, $d_{2}$, $d_{3}$ nodes on each of the three layers; they are labeled as $n_{1}(i)$, $n_{2}(j)$, $n_{3}(k)$, with indices $i=1,..,d_{1}$, $j=1,...,d_{2}$, and $k=1,...,d_{3}$. In Fig. 1 is shown an example where $d_{1}=4$, $d_{2}=2$, and $d_{3}=4$.

For example, the transformations on $n_{1}$ which lead to $n_{2}$ are defined as:

[TABLE]

Note that this choice of $f$ enforces a $(-1,1)$ encoding, as opposed to the $(0,1)$ encoding; this will be discussed later. The training error ($E$) is a mean-squared error; a classification error could also be used.

[TABLE]

Back-propagation is used, which is based on differential updates made to $w=(w_{0},w_{1},...,w_{d})$ using:

[TABLE]

where $\eta$ is the learning rate.

3 Different Parameterization

It may be the reader’s experience, as it has been the author’s, that there are advantages to having a simple parametrization of the system being optimized. In particular, it’s beneficial to have a 1-to-1 mapping between parameter values with the actual configuration of your system (i.e., the hyperplane configurations); that is not the case here. E.g., all $w$ values could be scaled up and down, and they would all describe the same hyperplane $w\cdot x=0$; that scale change is important for the function $f$, however. Another point is the lack of intuition that the usual parametrization provides: it’s simply not clear by looking at the parameter values, without any additional calculation, whether the w-values are appropriate for a given data set. Toward finding a different parametrization that doesn’t suffer from these shortcomings is the motivation for this paper.

The key point about the different parametrization is that it is based on features of the hyperplane– i.e., the minimum distance between the origin and the hyperplane ($c$), and the orientation of the hyperplane ($u$). Using those variables a hyperplane ($L$) can be written as $L=c+u\cdot x$, where $x$ is a point in space (i.e., the data). While clearly it’s almost the same as what has been traditionally used, it has the advantage that it’s a unique representation of the hyperplane. It can easily be checked that for each $(c,u)$ combination, there is exactly one hyperplane, and vice versa. Also, it is easy to partition all possible hyperplanes, by first fixing $c$ or $u$.

The two parametrizations are trivially connected (using $x_{0}=1$); the difference is having the overall scale pulled out:

[TABLE]

where $w^{\prime}=(w_{1},...,w_{d})$, $s=||w^{\prime}||$, $c=w_{0}/||w^{\prime}||$, $u_{i}=w_{i}/||w^{\prime}||$, $i=1,...,d$, and $||\cdot||$ denotes the $L_{2}$ norm. For simplicity, the new parameters are combined into one as $z=(s,c,u)$. The new parametrization will be referred to as z-param, and the traditional one as w-param. Optimizations for z-param will be done against the scalars $s$,$c$ and the vector $u$.

4 Examples of New Approach

A comparison is now made between the two parametrizations on a clean but sufficiently challenging test case: an autoencoder. Five 3-layer autoencoder examples, ranging in size from 8-3-8 to 128-7-128, are used to compare w-param and z-param. The sizes $(d_{1},d_{2},d_{3})$ were chosen to satisfy $d_{3}=d_{1}$ and $d_{2}=log_{2}(d_{1})$. This architecture is chosen to force the NN to learn a compact representation of the $d_{1}$ data points using only $d_{2}$ variables. For example, in Mitchell[4] it is explained how the data $(1,0,0,0,0,0,0,0)$, $(0,1,0,0,0,0,0,0)$,… essentially becomes encoded by $(1,0,0)$, $(0,1,1)$,…, where the $d_{2}$ layer is reminiscent of a binary encoding. In this supervised task, the target data ($t$) forces the nodes ($n_{3}$) on the third layer to reproduce the input data. Also, to keep this comparison as straightforward as possible, certain techniques were left out that are often employed: i.e., momentum, adjustable decay rate, mini-batch. Were these features to be included, they could be applied to both w-param and z-param.

Code for running these examples is available on a public repository[6]. Pseudocode will not be shown, since it is the same as the existing NN algorithm, and differs only with respect to the parameter updating. Here $\Delta w=-\eta\partial E/\partial w$ is replaced by its z-equivalent, and since $z=(s,c,u)$ there are three separate derivatives for each layer. This leads to the 6 derivatives shown below, which will be used for updating those parameters via $\Delta z=-\eta\partial E/\partial z$,

[TABLE]

where

[TABLE]

and $v=1,2$. Noticeable is that there is nothing in the model that enforces $||u||=1$. It is skipped in this presentation and will be discussed at a future time. The initial values for $z=(s,c,u)$ are: $s=1$, $c=0$, $u$ = random unit vector. Note that the same initialization is used for both w-param and z-param; the difference in the results follows from the different updating schemes applied to each. The choice of the initialization value $s=1$ was made to simplify the comparison between these two algorithms. In fact, using a very small non-zero $s$ leads to better results, and will be explored briefly later in this section.

Before comparing the two approaches over those different examples, an (approximate) optimal $\eta$ will be determined for each. This was done using a grid search over $\eta$, averaging 20 runs for each point (10 runs for $d_{1}=128$). The results for the best $\eta$ for z-param (i.e., $\eta_{z}$) and for w-param (i.e., $\eta_{w}$) are in Table 1.

Using the $\eta_{w}$ and $\eta_{z}$, the w-param and z-param algorithms were run over 1500 epochs, starting from the same initial conditions (as described earlier). The results are overlaid on each other: one plot for $d_{1}=16$ (Fig. 3) and one for $d_{1}=64$ (Fig. 3).

Note that in both graphs the better-performing, lower grouping corresponds to z-param, the new parametrization. These results were typical of the entire set: the z-param always performed better, reaching a lower training error more quickly. Most noticeable is that as $d_{1}$ increases, the variance of the final $E$ increases, as well as the final $E$ value itself.

To facilitate seeing the general trend as $d_{1}$ increases, those runs are averaged for each $d_{1}$ to produce Fig. 5 through Fig. 7. This is displayed in the figures for $d_{1}=16,32,64,128$.

These graphs make it more obvious that z-param always outperforms w-param. Indeed, the final $E$ of the z-param curves are typically about 1/10-th that of the w-param. It bears repeating that these two cases began from the same initial conditions on the hyperplanes and used the same mean squared error; the only difference is that the hyperplanes were parametrized and updated differently.

To better quantify the advantage z-param has over w-param, an "epoch speedup" is visually defined in Fig. 8 with respect to the averaged runs (cf. Fig. 5); it’s simply the ratio of epochs ($t_{2}/t_{1}$) needed to reach a given $E$[7].

Note this can only be computed at a training error ($E$) where both curves have a value. E.g., for very low training errors, only z-param has values, and the speedup cannot be computed. Thus the window of training error ranges from the min of the max $E$ values to the max of the min $E$ values, for each pair of w and z training error values. That range is then scaled from 0 to 100, and is referred to as the "Percent toward 0".

Shown in Fig. 9 is a typical graph of the epoch speedup, in this case for $d_{1}=16$.

Of note is how the speedup increases as the original curves reached lower $E$ values. There is no reason to believe this trend would not continue for higher epoch number. Also, in a sense these graphs don’t tell the whole story– the w-param appears to not be able to reach (in a reasonable time) the low $E$ values of the z-param.

The maximum speedup recorded for all the cases is shown in Table 2

Small s

The above comparisons were all made using the initial condition of $s=1$, which was done in large part to simplify the comparison. Having done that, one may now explore the effects of small $s$. Shown in Fig. 10 are the w-param and z-param for $d_{1}=128$ for $s=0.1$

Again z-param does better, but what is notable is how both outperformed their corresponding $s=1.0$ versions. Qualitatively, one can see the different runs coming together, and having a smaller variance for larger epoch values. There is also the emergence of a plateau early on, more easily seen in the w-param case. To explore this still further, the same graph was produced in Fig. 11, except using $s=0.0001$

The quality of the z-param (lower curves) is evident: it’s shifted left, reaches lower values, and has reduced variance. The w-param graphs have an increased plateau and less variance, but don’t reach noticeably lower $E$ values.

5 Parameter Initialization

This paper, while begun as an investigation into a different hyperplane parametrization, has also shed light on optimal parameter initializations. Beginning from the parameters for the z-param case, there are three types of parameters: the scale of $h$ (i.e., $s$), the distance of hyperplane to origin ($c$), and the orientation of hyperplane ($u$).

The scale ($s$) was best chosen to be a small number. In Fig. 11 it was seen to lead to a plateau region initially (especially for the w-param case). Presumably this allowed more time for $c$ and $u$ parameters to find more optimal values, thereby negating the influence of an initial random $u$. This would happen because, since $f(h)=f(s(c+u.x))$, a small $s$ would hide modest changes in $c$ and $u$, thereby initially allowing those parameters to more easily evolve toward optimal values. There is evidence for this in that the curves have coalesced for $s=0.1$ in Fig. 10, and have strongly coalesced as $s$ was made smaller to $s=0.0001$ in Fig. 11. Thus, when using z-param, it seems best to set $0<s\ll 1$, at least when there is a significant variance in individual runs as was seen earlier. Likewise, for the w-param case, the scale is set by $||w^{\prime}||$, where again $w^{\prime}=(w_{1},...,w_{d})$, so the corresponding scaled values are:

[TABLE]

where $s$ is the same as for z-param.

The distance of a hyperplane to origin ($c$) was set to 0, under the assumption that the data was shifted about its mean. This would ensure that all the data points do not fall on one side of the plane, making the hyperplane much less useful[2]. The effect of having a hyperplane completely on one side of a data cloud is that $h$ will become very large in magnitude, which leads to $f(h)$ being pinned to its min/max values, and also $f^{\prime}(h)$ being near zero. This is known as the zero-gradient problem. Here it is called being "caught in the doldrums", a sailing term used to describe a situation near the equator, where there is no wind, and hence no prospect of making progress. Being caught in the doldrums is equally disadvantageous for training a NN. To avoid this scenario, and ensure the hyperplanes (nearly) always intersect the data cloud, the input layer is shifted about its mean. For later layers, it’s preferable to not have to keep doing that, so to mitigate that the $(-1,1)$ encoding is used instead of the $(0,1)$ encoding. This has the advantage of having positive and negative values, and hence being somewhat self-averaging (toward 0).

The orientation of the hyperplane ($u$) should obviously be in a random direction. A correct prescription for constructing such a vector is to draw from a normal distribution for each component, and then normalize the result[5]. If one instead draws from a uniform distribution (as is commonly done), and normalizes that, the resulting $u$ will be biased toward the corners of the enclosing hypercube. The same approach can be used with $w^{\prime}$ (in w-param) as for $u$ (in z-param).

6 Final Remarks

In this paper, the ramifications of a different parametrization (z-param) of the hyperplanes were investigated in the NN algorithm. The motivation was that a more intuitive and straightforward representation could help the hyperplanes more easily explore their parameter space.

The results show that by switching to z-param, learning can be achieved much more quickly. It’s evident from the "epoch speedup" graphs (cf. Fig. 9) that as training continues, there is increasingly more to be gained from using the z-param. Keep in mind though that the epoch speedup numbers are not perfectly representative of the wall clock time for implementing this algorithm. The FLOPS are slightly higher for z-param, and the parallelizability may be different (although it appears similar).

In addition to the above, the z-param approach presented a simpler situation with respect to initializing the parameters. In the process it was noted, at least for the examples studied, that high variance training error runs might be a motivation for instead initializing with a very small $s$.

Investigations into this new parametrization have just begun and there are clearly many avenues of research left to be pursued. Also, since this is only a change in the parametrization of the hyperplanes, it means it can be substituted into existing NN applications that use the existing w-param. Hence, this new parametrization can be applied on a wide scale.