\section{Appendix}

\subsection{Weights for minimal architecture}

We describe weights that solve Life for the minimal architecture $\lifenet(1, 1)$.

The first layer has two $3 \times 3$ convolutional filters, each with bias, described as follows:
\begin{align*}
    W_{1,1} &= \begin{pmatrix}
    1 & 1 & 1 \\
    1 & \nicefrac{1}{10} & 1 \\
    1 & 1 & 1
    \end{pmatrix} \\
    b_{1,1} &= -3 \\
    W_{1, 2} &= \begin{pmatrix}
    1 & 1 & 1 \\
    1 & 1 & 1 \\
    1 & 1 & 1
    \end{pmatrix} \\
    b_{1,2} &= -2 
\end{align*}
where $W_{1,1}$ and $W_{1,2}$ describes the weights of the first and second convolutional filters, respectively, and $b_{1,1}$ and $b_{1,2}$ similarly describes the bias. Each output is fed through a ReLU function.

The second layer has a single $1 \times 1$ filter which combines the output of the two filters from the previous layer.
\begin{align*}
    W_{2, 1} = \begin{pmatrix}
        -10
    \end{pmatrix} \oplus \begin{pmatrix}
        1
    \end{pmatrix}
\end{align*}
where the first component corresponds with the first-layer output of the first filter and the second component corresponds with the output of the second filter.Each output is fed through a ReLU function.

We add one more layer, as a convenience for learning:
\begin{align*}
    W_{3} = \begin{pmatrix}
        2s
    \end{pmatrix}, b_{3} = -s
\end{align*}
for an arbitrary large $s$, and in practice, $20$. The output is then fed through a sigmoid function.

Thus, the entire architecture, given a Life input \textit{x}, has that $N(x)$ computes the next step, where $N$ is defined as:
\begin{align*}
    N_1 &= \text{ReLU}((x \mathbin{\mathpalette\make@circled*} W_{1,1} + b_{1, 1}) \oplus (x \mathbin{\mathpalette\make@circled*} W_{1,2} + b_{1, 2})) \\
    N_2 &= \text{ReLU}(N_1 \mathbin{\mathpalette\make@circled*} (W_{2,1} \oplus W_{2,2})) \\
    N &= \text{Sigmoid}(N_2 \mathbin{\mathpalette\make@circled*} W_{3} + b_{3})
\end{align*}

\section{Introduction}

Recent findings suggest that neural networks can be ``pruned'' by 90\% or more to eliminate unnecessary weights while maintaining performance similar to the original network . Similarly, the \textit{lottery ticket hypothesis} \cite{frankle2018lottery} proposes that neural networks contain subnetworks, called \textit{winning tickets}, that can be trained in isolation to reach the performance of the original. These results suggest that neural networks may rely on these lucky initializations to learn a good solution. Rather than extensively exploring weight-space, networks trained with gradient-based optimizers may converge quickly to local minima that are nearby the initialization, many of which will be poor estimators of the dataset distribution. If some subset of the weights must be in a winning configuration for a neural network to learn a good solution to a problem, then neural networks initialized with random weights must be significantly larger than the minimal network configuration that would solve the problem in order to optimize the chance having a winning initialization. Furthermore, small networks with winning initial configurations may be sensitive to small perturbations.

Similarly, gradient-based optimizers sample the gradient of the loss function with respect to the weights by averaging the gradient at a few elements of the dataset. Thus, a biased training dataset may bias the gradient in a way that can be detrimental to the success of the network. Here we examine how the distribution of the training dataset affects the network's ability to learn.

In this paper, we explore how effectively small neural networks learn to take as input a configuration for Conway's Game of Life (\textit{Life}) \cite{berlekamp2018winning}, and then output the configuration $n$ steps in the future. Since this task can be implemented minimally in a convolutional neural network with $2n+1$ layers and $23n+2$ trainable parameters, a neural network with identical architecture should, in principle, be able to learn a similar solution. Nonetheless, we find that networks of this architecture rarely find solutions. We show that the number of weights necessary for networks to reliably converge on a solution increases quickly with $n$. Additionally, we show that the probability of convergence is highly sensitive to  small perturbations of initial weights.  Finally, we explore properties of the training data that significantly increase the probability that a network will converge to a correct solution. While Life is a toy problem, we believe that these studies give insight into more general issues with training neural networks. In particular, we expect that other neural network architectures and problems exhibit similar issues. We expect that networks likely require a large number of parameters to learn any domain, and that small networks likely exhibit similar sensitivities to small perturbations to their weights. Furthermore, optimal training datasets may be highly particular to certain parameters. Thus, with the growing interest in efficient neural networks \cite{NIPS2015_5784, hassibi1993second, hinton2015distilling, lecun1990optimal, li2016pruning}, this results serve as an important step forward in developing ideal training conditions.

\subsection{Conway's Game of Life} 

Prior studies have shown interest in applying neural networks to model physical phenomena in applications including weather simulation and fluid dynamics \cite{baboo2010efficient, maqsood2004ensemble, mohan2018deep, shrivastava2012application}. Similarly, neural networks are trained to learn computational tasks, such as adding and multiplying \cite{kaiser2015neural, graves2014neural, joulin2015inferring, trask2018neural}. In all of these tasks, neural networks are required to learn hidden-step processes in which the network must learn some update rule that can be generalized to perform multi-step computation.

Conway's \textit{Life} is a two-dimensional cellular automaton with a simple local update rule that can produce complex global behavior. In a Life configuration, cells in an $n \times m$ grid can be either alive or dead (represented by $1$ or $0$ respectively). To determine the state of a given cell on the next step, Life considers the $3 \times 3$ grid of neighbors around the cell. Every step, cells with exactly two alive neighbors will maintain their state, cells with exactly three alive neighbors will become alive, and cells with any other number of neighbors will die (Figure~\ref{fig:lifeexample}). We consider a variant of Life in which cells outside of the $n \times m$ grid are always considered to be dead. Despite the simplicity of the update rule, Life can produce complex output over time, and thus can serve as an idealized problem for modeling hidden-step behavior.

\section{Related Work}

Prior research has shown interest in whether neural networks can learn particular tasks. Joulin et al. \cite{joulin2015inferring} argue that certain recurrent neural networks cannot learn addition in a way that generalizes to an arbitrary number of bits. Theoretical work has shown that sufficiently overparameterized neural networks converge to global minima \cite{9081945, du2018gradient}. Further theoretical work has found methods to minimize local minima \cite{kawaguchi2019elimination, nguyen2017loss, kawaguchi2016deep}. Nye et al. \cite{nye2018efficient} show that minimal networks for the parity function and fast Fourier transform do not converge to a solution unless they are initialized close to a solution.

Increasing the depth and number of parameters of neural networks has been shown to increase the speed at which networks converge and their testing performance \cite{arora_optimization_2018, park_effect_2019}. Similarly, Frankle et al. \cite{frankle2018lottery} find that increasing parameter count can increase the chance of convergence to a good solution. Similarly, Li et al. \cite{li_measuring_2018} and Neyshabur et al. \cite{neyshabur_towards_2018} find that training near-minimal networks leads to poor performance. Choromanska et al. \cite{choromanska_loss_2015} provide some theoretical insight into why small networks are more likely to find poor local minima.

Weight initialization has been shown to matter in training deep neural networks. Glorot et al. \cite{glorot_understanding_2010} find that initial weights should be normalized with respect to the size of each layer. Dauphin et al. \cite{dauphin_metainit_2019} find that tuning weight norms prior to training can increase training performance. Similarly, Mishkin et al. \cite{mishkin_all_2016} propose a method for finding a good weight initialization for learning. Zhou et al. \cite{zhou_deconstructing_2020} find that the sign of initial weights can determine if a particular subnetwork will converge to a good solution.

\cite{neyshabur_towards_2018}

There is significant research into weight pruning and developing efficient networks \cite{lecun1990optimal, hassibi1993second, NIPS2015_5784, li2016pruning, hinton2015distilling, li_measuring_2018}, including the lottery ticket hypothesis, which suggests that gradient descent allows lucky subnetworks to quickly converge to a solution \cite{frankle2018lottery}.

Finally, there is interest in learning hidden step computational processes including algorithms and arithmetic \cite{kaiser2015neural, graves2014neural, joulin2015inferring, trask2018neural}, fluid dynamics \cite{baboo2010efficient, maqsood2004ensemble, mohan2018deep}, and weather simulation \cite{shrivastava2012application}.

Among the above papers, there are studies that have already shown that weight initialization, overparameterization, and training dataset statistics can determine whether or not a neural network can converge to a good solution to a problem. However, in this paper, we evaluate these domains on the Game of Life, a non-trivial but simple toy problem for which an exact minimal solution is known, allowing us to derive insights that relate to this minimal solution, which is not possible in vision or other similar domains.

\section{Experiments and Results}

\begin{figure}[t]
\includegraphics[width=12cm]{game_of_life}
\centering
\caption{An example of an $8 \times 8$ cell board of Life over six time steps, evolving in time from left to right. White pixels are considered alive and black pixels are considered dead.}
\label{fig:lifeexample}
\end{figure}

We define the \textit{Life problem} as a function-learning problem. In particular, if $x$ is a matrix of $1$s and $0$s, define $G(x)$ to be the next step in Life, according to the previously described update rules. Then, we define the Life problem to be the problem of predicting $G(x)$ given $x$. Similarly, we define the $n$-step-Life problem as the problem of learning to predict $G^n(x)$ given $x$. Since Life has a local update rule that considers a $3 \times 3$ grid to determine the state of the center cell, we can model Life with an entirely convolutional neural network, i.e., a neural network without any fully connected or pooling layers. A convolutional layer with two $3 \times 3$ filters that feeds into a second convolutional layer with one $1 \times 1$ filter, can solve the $1$-step-Life problem efficiently, i.e., any fewer layers or convolutional filters would yield an architecture which cannot implement $1$-step-Life. Thus, we call it the \textit{minimal} architecture for Life. We use ReLU activation functions to prevent vanishing gradients for when the architecture is generalized to the $n$-step-Life problem by stacking layers. The second convolutional layer feeds into a final convolutional output layer with one $1 \times 1$ filter with a sigmoid activation function. This forces all outputs to approximate either $0$ or $1$ but does not, on its own, perform meaningful computation, and thus is included for this convenience. With appropriate weights, this constructs a three-layer convolutional neural network that can solve the $1$-step-Life problem with $25$ weights. We generalize this architecture to solve the $n$-step-Life problem by stacking $n$ copies of this network, as shown in Figure ~\ref{fig:lifemodel} (right). 

\begin{figure}[t]
\includegraphics[width=12cm]{life_model}
\centering
\caption{Neural network architecture diagrams for the 1-step minimal model and $\lifenet(n, m)$. On the left, the 1-step minimal architecture consists of an input layer that feeds into a convolutional layer with two $3 \times 3$ filters with ReLU activation, then into a convolutional layer with one $1 \times 1$ filter with ReLU activation, fed into a similar convolutional layer but with sigmoid activation for decoding. On the right, the architecture for $\lifenet(n, m)$ consists of the same as the minimal model, except where the first two hidden layers consist of $2m$ and $m$ filters respectively, and are repeated $n$ times, where $m$ is the factor of overcompleteness (see text).}
\label{fig:lifemodel}
\end{figure}

We have hand-engineered weights for these architectures that implement the underlying rule and thus solves the $n$-step-Life problem with perfect accuracy. We conclude that this minimal neural network architecture can solve the $n$-step-Life problem with a $2n+1$ layer convolutional neural network with $23n+2$ weights. In principle, a neural network with an identical architecture should be able to learn a similar solution.

\subsection{Life Architecture} \label{lifearchitecture}

We construct a class of architectures to measure how effectively networks of varying sizes solve a hidden-step computational problem. In particular, we employ an architecture similar to the one described in the previous section: an entirely convolutional neural network with $n$ copies of a convolutional layer with $3 \times 3$ filters that feed into a convolutional layer with $1 \times 1$ filters, and finally, a convolutional layer with a single $1 \times 1$ filter and sigmoid activation to decode the output into a Life configuration. When the architecture has $n$ copies of the described layers, we say that it is an $n$\textit{-step architecture}. In the minimal\footnote{A reviewer helpfully pointed out that an even smaller network can be constructed to solve Life, with a single $3 \times 3$ convolution that counts neighbors, outputs a 0 if there are two neighbors, 1 if there are three neighbors, and -1 otherwise, and then is added to the input and fed through a Heaviside activation function. However, our model is minimal given the constraint that we are using a traditional feedforward network with ReLU activation.} solution, each repeated $3 \times 3$ convolutional layer has two filters and each repeated $1 \times 1$ convolutional layer has one filter. When a similar architecture has $2m$ $3 \times 3$ filters and $m$ $1 \times 1$ filters in each respective repeated layer, we say that the architecture is $m$\textit{-times overcomplete} with respect to the minimal architecture. We let $\lifenet(n, m)$ describe the $n$-step $m$-times overcomplete architecture.

To train instances of each architecture, we initialize the weights randomly from a unit normal distribution. The networks are implemented in Keras \cite{chollet2015} on top of TensorFlow \cite{tensorflow2015-whitepaper} and trained using the Adam optimizer ($\alpha=0.001, \beta_1=0.9, \beta_2=0.999$) \cite{kingma2014adam} with a binary cross-entropy loss function on the output of the model. Each instance is trained with 1 million randomly generated training examples separated into 100 epochs of 10,000 training examples each, with a batch size of 8. Each training and testing example is generated as follows: first, we uniformly draw a \textit{density} $d$ from $[0, 1]$, and then generate a $32 \times 32$ cell board such that each cell is alive with probability $d$. It is extremely unlikely that the network will ever see the same training example twice. Thus, separating testing data into a testing set and a validation set is unnecessary, since novel data can be generated on the fly. To improve computational efficiency, all networks with the identical parameters are implemented so that they can be trained in parallel using the same randomly generated dataset. 

\subsection{The Difficulty of Life}

To quantify the effectiveness of a given neural network architecture, we measure the probability that a random initialization of the network converges to a solution after being shown one million training examples. Because $\lifenet(n, m)$ can only implement a $3 \times 3$ update rule in each step of computation and is minimal in this sense, for $\lifenet(n, m)$ to solve the $n$-step-Life problem, it must learn the underlying rule. Thus, we consider an instance of $\lifenet(n, m)$ to be successful when it learns the correct underlying rule, and can therefore predict $G^n(x)$ with perfect accuracy for all initial states $x$. Any instance of $\lifenet$ that does not have perfect accuracy did not learn the underlying rule and is thus considered unsuccessful. We wish to determine \[ P[\text{ success of } \lifenet(n, m) \mid n, m \ ] \]

To accomplish this, we train 64 instances of $\lifenet(n, m)$ for $1 \leq n \leq 5$ and $1 \leq m \leq 24$. We omit certain combinations due to computational limitations. In Figure ~\ref{fig:successrate} we plot the percentage of instances of $\lifenet(n, m)$ that successfully learn the $n$-step-Life problem.

\begin{figure}[t]
\includegraphics[width=6cm]{success_rates}
\centering
\caption{Measured probability that the $m$ times overcomplete $n$-step-Life architecture learns successfully. Each line corresponds with a particular $n$. Each point plots the percentage of 64 instances of $\lifenet(n, m)$ with random initializations sampled from a unit normal distribution that learned the rules of $n$-step-Life after 1 million training examples. We train instances of $\lifenet(n, m)$ for values $1 \leq n \leq 5$ and $1 \leq m \leq 24$, excluding many combinations due to computational constraints. For $n>1$, none of the instances of $\lifenet$ successfully learned with the minimal($m=1$) architecture. As $n$ increases, the degree of overcompleteness required for consistent converges increases rapidly.}
\label{fig:successrate}
\end{figure}

We observe that of the minimal ($m=1$) architectures, only instances for the $1$-step-Life problem ($\lifenet(1, 1)$) converged on a solution, with a success rate of approximately 4.7\%. Instances of architectures to solve the one and two-step-Life problem had a greater than 50\% chance of converging to a solution when the architecture was at least $3$ and $4$-times overcomplete, respectively. Instances of architectures to solve the $n$-step-Life problem for $n \geq 3$ require an overcompleteness greater than 24, the highest degree of overcompleteness we tested, due to computational constraints. This explosive growth rate suggests that the degree of overcompleteness required for consistent convergence of the $n$-step-Life problem grows quickly with respect to $n$.

Strikingly, for $3 \leq n \leq 5$, we do not observe the hypothesized scaling behavior. Rather, we observe that for high overcompleteness, the architectures for $n=4$ outperforms $n=3$, and $n=5$ performs similarly to $n=3$. While all three $n$ require many more parameters than the minimal architecture to consistently converge, we would expect that $n=3$ requires fewer than $n=4$, which would require fewer than $n=5$. We have multiple hypotheses: firstly, we may observe this result due to noise or dataset artifacts; secondly, our parameterization of Life may have consistent behavior for all $3 \leq n \leq 5$, which may make the difficulty of learning any $3 \leq n \leq 5$ steps similar.

\begin{figure}[t]
\includegraphics[width=14cm]{model_rate_of_convergence}
\centering
\caption{\textit{First five graphs:} Binary cross-entropy loss over the duration of training of the 64 networks trained to solve the $n$-step-Life problem for $1 \leq n \leq 5$. The horizontal axis corresponds to number of epochs of training, which is measured as 10,000 training examples. The architecture parameters $\lifenet(n, m)$ of the networks associated with the graph are labeled above each graph. We choose to plot losses corresponding to networks that are $8$-times overcomplete and omit the other degrees of overcompleteness from this figure, although they follow similar trends. For clarity, we omit from the graphs the loss of networks that eventually diverged to a degenerate state where the networks predicted all cells to be dead, regardless of the input Life configuration. These examples converge on a loss that is well over 1. \textit{Last graph:} Average earliest point of convergence of $\lifenet(n, m)$ for $m=8$ and $1 \leq n \leq 4$. Note that $n=5$ is excluded because no instances of $\lifenet(5, 8)$ converge. We compute the earliest point of convergence for each network by observing the first epoch where the loss falls below 0.01, indicating that the network has reached a stable 100\% accuracy. We average all earliest points of convergence for a given $n$ and $m$. The number of epochs necessary for convergence increases quickly with $n$.}
\label{fig:lifenetlosses}
\end{figure}

We plot the loss of the instances of $\lifenet(n, m)$ for $1 \leq n \leq 5$ and $m=8$ in Figure ~\ref{fig:lifenetlosses} to illustrate typical rates at which the networks converge to a solution. In addition, we compute the average earliest point of convergence for converged networks of $\lifenet(n, m)$ architecture for $1 \leq n \leq 4$ and $m=8$ (Figure ~\ref{fig:lifenetlosses}). The earliest point of converge is computed by determining the earliest epoch in which the loss of a convergent network falls below 0.01 to indicate the network has learned a solution to the $n$-step-Life problem. We exclude non-converged networks from this metric.

\subsection{Weight Perturbations and Learning}

\begin{figure}[t]
\includegraphics[width=12cm]{perturbation_rates}
\centering
\caption{\textit{Left:} Fraction of converged $\lifenet(1, 1)$ networks with weights initialized with a $k$-sign perturbation of a converged solution to the $1$-step-Life problem. \textit{Center:} Same as \textit{left} except weights initialized with $k$-sign perturbation of the original initial weights that converged to the solution. \textit{Right:} Same as \textit{center} except weights initialized with a uniform perturbation of the original initial weights. A $k$-sign perturbation of weights is defined as a perturbation in which $k$ weights are chosen randomly from a uniform distribution and replaced with the same magnitude weight with opposite sign. In all cases, 128 networks with the specified weight initialization are trained over 50 epochs, which is well over the number of epochs required for convergence for instances of $\lifenet(1, 1)$. We omit the graph for uniform perturbations of converged weights, as small perturbations have little effect given the magnitude of the converged weights. }
\label{fig:perturbationsuccessrate}
\end{figure}

To observe the robustness of weight initializations and of learned solutions, we perturb successful weight initializations and solutions of the minimal $1$-step-Life architecture $\lifenet(1, 1)$. In particular, we perform two perturbations: the $k$-sign perturbation and the uniform perturbation. The $k$-sign perturbation modifies weights as follows: we select $k$ weights randomly from a uniform distribution. We replace each chosen weight with a weight of the same magnitude but of opposite sign. The uniform perturbation modifies weights by adding a value selected uniformly from the range $[-r, r]$ for a given perturbation magnitude $r$. We choose a weight initialization of a network which converges to a solution to the $1$-step-Life problem. We initialize and train instances of the minimal architecture with these weights perturbed by $k$-sign perturbations for $1 \leq k \leq 8$ and uniform perturbations for $r \in \{0.25, 0.5, 0.75, 1.0\}$. Similarly, we initialize and train instances of the minimal architecture with the described $k$-sign and uniform perturbations of the converged solution of this network. For each perturbation type, we train 128 instances. 

We plot the fraction of successful networks for each perturbation type in Figure ~\ref{fig:perturbationsuccessrate}. Notably, a $1$-sign perturbation of the original initial weights of the successful network causes the network to fail to converge approximately 20\% of the time, and only 4--6 sign perturbations are required to drop the success rate below 50\%. This suggests that for minimal networks, the weight initialization is sensitive to perturbations. This is not unique to sign perturbations. Even a relatively small uniform perturbation of 0.25 magnitude (where weights are changed by 0.125 in expectation) causes the tested networks to fail to learn approximately 36\% of the time. Finally, we observe that even a $1$-sign perturbation of an already converged solution causes approximately 90\% of models to fail to learn, suggesting that converged solutions are very sensitive to sign perturbations. Furthermore, since typical weights are small in the converged solution (weights have a mean of approximately $0.270$ and standard deviation of approximately $-2.17$), sign perturbations do not represent large-magnitude changes.

\subsection{An Optimal Training Dataset}

\begin{figure}[t]
\includegraphics[width=12cm]{density_and_dataset}
\centering
\caption{\textit{Top:} Fraction of minimal networks that converge to a solution to the $1$-step-Life problem (\textit{left and center}) and $2$-times overcomplete networks (\textit{right}) when trained with datasets of a given $d$-density dataset. The \textit{left} and \textit{center} graphs refer to the same training configurations, however, the \textit{left} graph includes the rate of convergence for datasets with $d$ between $0.1$ and $0.9$ with $0.05$ intervals while the \textit{center} graph has data for $d$ between $0.2$ and $0.5$ with $0.0125$ intervals. \newline \newline \textit{Bottom:} \textit{Left:} the probability that an arbitrary cell is alive after $1$ step of Life of an instance of a $32 \times 32$ cell $d$-density dataset, given $d$. This curve peaks at approximately $d \approx 0.38$. \textit{Right:} two examples from the generated datasets ($0.8$-density and $0.38$-density). We generate a $d$-density dataset by choosing $32 \times 32$ cell grids as training examples where cells are alive with probability $d$.}
\label{fig:datasetanddensity}
\end{figure}

Many deep learning systems are restricted by the dataset which is available for training. We examine how a class of training datasets affects the success rate of near-minimal networks learning the $1$-step-Life problem. In particular, we construct a class of training datasets: the \textit{$d$-density dataset}, a $32 \times 32$-cell dataset in which cells are chosen independently to be alive with probability $d$. Note that the dataset described in Section ~\ref{lifearchitecture} is a generalization of this class of datasets in which $d$ is chosen uniformly, which we call the \textit{uniform-density} dataset. We show examples of these datasets in Figure ~\ref{fig:datasetanddensity}.

We train 128 instances of $\lifenet(1, 2)$ on the $d$-density datasets for $0.1 \leq d \leq 0.9$ with intervals of $0.05$. We train $\lifenet(1, 1)$ on the same datasets, and in addition, on $d$-density datasets for $0.2 \leq d \leq 0.5$ with intervals of $0.0125$. Surprisingly, we find a sharp spike in probability of success for values of $d$ between approximately 0.3 and 0.4. When $d=0.35$, we observe a 14\% success rate for the minimal model, a strikingly high success rate considering that it is approximately double the success rate of the $0.4$-density dataset and triple the success rate of the $0.3$-density dataset (Figure ~\ref{fig:datasetanddensity}). The same result, though less exaggerated, appears for $\lifenet(1, 2)$, where the performance increases drastically for $d=0.35$ and $d=0.4$ (Figure ~\ref{fig:datasetanddensity}). The tiny range in which performance increases significantly suggests that there is likely a critical value $d_0$ such that the $d_0$-density dataset is in this sense optimal. We hypothesize that the value of $d_0$ coincides with the peak of the graph shown in Figure ~\ref{fig:datasetanddensity}, which plots the probability that a cell is alive after one step of Life given that the initial configuration of Life is drawn from a $d$-density dataset, for a given $d$. This would place $d_0 \approx 0.38$. We predict that an optimal dataset must satisfy a condition in which the probability of observing each possible $3 \times 3$ local configuration of Life reaches an equilibrium that allows the computed average gradient of the weights with respect to the loss function and the training examples to direct the weights quickly to a solution. For example, for very small $d$, we expect most cells to be dead after one step of Life given an initial state sampled from the $d$-density dataset. Thus, in this case, the computed average gradient of the weights will tend to drive the network towards a solution which predicts most cells to be dead. The density which maximizes the probability that a cell will be on after one step of Life will maximize the occurrence of cells with exactly three neighbors and alive cells with exactly two neighbors, any instance of which will increase the number of cells that are alive in the next step of Life. We hypothesize that frequent observation of these configurations are critical for a near-minimal network to solve the $n$-step-Life problem.

\section{Discussion}

The lottery ticket hypothesis \cite{frankle2018lottery} proposes that when training a convolutional neural network, small lucky subnetworks quickly converge on a solution. This suggests that rather than searching extensively through weight-space for an optimal solution, gradient-descent optimization may rely on lucky initializations of weights that happen to position a subnetwork close to a reasonable local minima to which the network converges. This would make convolutional neural networks, especially those which are near-minimal in architecture, extremely sensitive to weight initializations and other parameters that affect the search space of the network, such as the distribution of the dataset. 

In order to determine the significance of weight vector initializations in neural networks, we examined how initial weight configurations of small convolutional neural networks that are trained to solve the $n$-step-Life problem contribute to the ability for the network to learn on a correct solution. We find that despite the fact that the $n$-step-Life problem can be implemented minimally in a neural network with $\lifenet(n, 1)$ architecture, when networks of this architecture are trained to solve the problem with the standard state-of-the-art gradient-based optimizer, Adam \cite{kingma2014adam}, the networks rarely learn a successful solution. To determine the scaling behavior of the required number of parameters a network requires to consistently learn a solution to $n$-step-Life, we test the probability at which neural networks with varying degrees of overcompleteness learn a solution. Our results suggest that the required degree of overcompleteness of the network is large, a characteristic predicted by the lottery ticket hypothesis. 

While Conway's Game of Life itself is a toy problem and has few direct applications, the results we report here have implications for similar tasks in which a neural network is trained to predict an outcome which requires the network to follow a set of local rules with multiple hidden steps. Examples of such problems include but are not limited to machine-learning based logic or math solvers, weather and fluid dynamics simulations, and logical deduction in language or image processing. In these instances, without enormously overcomplete networks, gradient descent based optimization methods may not suffice to learn solutions to these problems. Furthermore, such a result may generalize to problems that do not explicitly involve local hidden step processes, such as classification of images and audio, and virtually every other application of machine learning. In addition, significant effort has gone into developing faster and smaller networks with similar performance to their larger counterparts. Our result suggests that these smaller networks may necessarily require alternative training methods, or methods to identify optimal weight initializations. 

Additionally, we measure the robustness of the initial and converged weights to $k$-sign and uniform perturbations. In accordance with our prediction based on the lottery ticket hypothesis, we find that weights of minimal architectures are highly sensitive to tiny perturbations.

Finally, we explore the role of dataset in learning a solution to $n$-step-Life for near-minimal architectures. We find a sharp increase in success rate for a dataset in which cells are chosen to be alive with probability $d_0 \approx 0.38$, which appears to coincide with the parameter $d$ that, given an initial Life configuration drawn from the $d$-density dataset, maximizes the probability that any given cell is alive after one step of Life. We hypothesize that the narrow range in which the probability of success increases drastically is a result of the precise conditions that optimize the probability that certain local $3 \times 3$ configurations of Life occur that are critical for learning, such as instances where a cell has exactly two or three neighbors. 

We predict that the tiny magnitude of the range of densities that allow for increased learning potential is specific to Conway's Game of Life and the particular architectures we train. However, other neural networks, especially small networks, may suffer from similar problems. Even datasets which seem intuitively reasonable may contain glaring biases that prevent neural networks from learning the underlying rules. Furthermore, in many instances, the dataset parameters may need to be tuned near perfectly in order to observe increases in performance.

In conclusion, we find that networks of the $\lifenet$ architecture that are trained to predict the configuration of Life after $n$ steps given an arbitrary initial configuration require a degree of overcompleteness that scales quickly with $n$ in order to consistently learn the rules of Life. Similarly, we show that weight initializations and converged solutions are extremely sensitive to small perturbations. Finally, we find that these networks are dependent on very strict conditions of the dataset distribution in order to observe a significant increase in success probability. These observations are consistent with the predictions of the lottery ticket hypothesis, and have important consequences in the field.

\section{Broader Impact}

This paper provides insight into the lottery ticket hypothesis and why neural networks may fail to learn particular tasks. However, the paper can similarly be interpreted to provide prescriptive claims about how to train neural networks. In particular, gradient-based optimization methods require networks to have large degrees of overcompleteness; thus to learn complex problems, neural networks should increase in size. Additionally, neural networks may be highly sensitive to the dataset distribution; thus datasets should be constructed and selected based on parameters that optimize this distribution for learning.

These prescriptive claims, however, may have adverse implications in the world. For example, increasing the number of weights of a network is not free, both financially and in terms of energy consumption and carbon emission. Our result may incentivize greater carbon emission which can contribute negatively to our global environment and increase the rate of climate change. Furthermore, we suggest developing finely tuned datasets that are optimal for learning. This may incentivize organizations to collect inappropriate amounts of invasive data on individuals to facilitate machine learning.

Instead, we hope that this paper will promote research into the limitations of neural networks so that we can better understand the flaws that necessitate overcomplete networks for learning. We hope that our result will drive development into better learning algorithms that do not face the drawbacks of gradient-based learning.

\medskip

\small

\printbibliography

