Reverse-Engineering Deep ReLU Networks

Introduction

A deep neural network computes a function from inputs to outputs, where the structure and parameters of the network control the function that is expressed. While each parameter influences the overall function, this influence is highly nonlinear, and the effects of different neurons within the network would appear superficially to be hopelessly entangled. Consequently, it has been widely supposed in the field that it is impossible to recover the structure and parameters of a network merely by observing its output on different inputs.

Were it possible to reverse-engineer a neural network from the function it computes, there could be serious implications for security and privacy. In many deployed deep learning systems, the output is freely available but the network used to generate that output is not. The ability to recover a confidential network could even expose data used to train the network if such data could be reconstructed from the network’s weights.

The related question of reverse-engineering biological neural networks is of foundational interest in neuroscience. Experimental neuroscientists can record the output of some neurons (e.g. complex cells in primary visual cortex) but not others (e.g. simple cells) and must also infer the synaptic weights between them. Our understanding of the brain would be greatly improved if it were possible to identify the internal components of a neural circuit based on recordings of the output of that circuit.

In this work, we show mathematically and empirically that it is, in fact, often possible to recover the structure and weights of an unknown ReLU network by querying it. Our approach leverages the fact that a ReLU network is piecewise linear and transitions between linear pieces when one of the ReLUs of the network transitions from its inactive to its active state. For neurons in the first layer of the network, such transitions occur along hyperplanes through input space; the equations of these hyperplanes determine the weights and biases of the first layer (up to sign and constant scaling). For neurons in subsequent layers, transitions occur along “bent hyperplanes” that bend where they intersect bent hyperplanes associated with earlier layers. Measuring the intersections between bent hyperplanes allows us to recover the weights between the corresponding neurons.

We prove that the architecture, weights, and biases of a deep ReLU network can be recovered (up to isomorphism) from the arrangement of regions on which the network is linear.

We describe an algorithm to recover the network by approximating the boundaries between these linear regions, with the only information given about the network being its output on specified queries.

We demonstrate the success of our algorithm in reverse-engineering both trained and untrained ReLU networks.

Each of these contributions significantly advances the state of the art. No prior work has, to our knowledge, been able to deduce even the first layer of a fully-connected network with 2 hidden layers. By contrast, our theoretical results and algorithm hold for reverse-engineering any layer of a network of any depth. Furthermore, we show empirically that our algorithm is able to reconstruct the first layer of 2-, 3-, and 4-layer networks, as well as the second layer of 2-layer networks.

Related work

Various works within the deep learning literature have considered the problem of inferring a network given its output on inputs drawn (non-adaptively) from a given distribution. It is known that this problem is in general hard (Goel et al., 2017), though positive results have been found for certain specific choices of distribution in the case that the network has only one or two layers (Ge et al., 2019; Goel & Klivans, 2017). By contrast, we consider the problem of reconstructing a network of arbitrary depth, given the ability to issue queries at specified input points. In this work, we leverage the theory of linear regions within a ReLU network, an area studied e.g. by Telgarsky (2015); Raghu et al. (2017); Hanin & Rolnick (2019a). Most recently, Hanin & Rolnick (2019b) considered the boundaries between linear regions as arrangements of “bent hyperplanes”. Milli et al. (2019); Jagielski et al. (2019) show the effectiveness of this strategy for networks with one hidden layer. For inference of other properties of unknown networks, see e.g. Oh et al. (2019).

Neuroscientists have long considered similar problems with biological neural networks, albeit armed with prior knowledge about network structure. For example, it is believed that complex cells in the primary visual cortex, which are often seen as translation-invariant edge detectors, obtain their invariance through what is effectively a two-layer neural network (Kording et al., 2004). A first layer is believed to extract edges, while a second layer essentially implements max-pooling. Many biological neurons appear to be well modeled as the ReLU of a linear combination of their inputs (Chance et al., 2002). Heggelund (1981) perform physical experiments akin to our approach of identifying one ReLU at a time, by applying inputs that move individual neurons above their critical threshold one by one. Being able to solve such problems more generically would be useful for a range of neuroscience applications.

Theoretical framework

Permutation. The order of neurons in each layer of a network $\mathcal{N}$ does not affect the underlying function. Formally, let $p_{k,\sigma}(\mathcal{N})$ be the network obtained from $\mathcal{N}$ by permuting layer $k$ according to $\sigma$ (along with the corresponding weight vectors and biases). Then, $p_{k,\sigma}(\mathcal{N})$ is isomorphic to $\mathcal{N}$ for every layer $k$ and permutation $\sigma$.

Scaling. Due to the ReLU’s equivariance under multiplication, it is possible to scale the incoming weights and biases of any neuron, while inversely scaling the outgoing weights, leaving the overall function unchanged. Formally, for $z$ the $i$th neuron in layer $k$ and for any $c>0$, let $s_{z,c}(\mathcal{N})$ be the network obtained from $\mathcal{N}$ by replacing ${\bf W}^{k}_{\cdot i}$, ${\bf b}^{k}_{i}$, and ${\bf W}^{k+1}$ by $c{\bf W}^{k}_{\cdot i}$, $cb^{k}_{i}$, and $(1/c){\bf W}^{k+1}_{i\cdot}$, respectively. It is simple to prove that $s_{z,c}(\mathcal{N})$ is isomorphic to $\mathcal{N}$ (see Appendix A).

It is worth noting that permutation and scaling are isomorphisms for every ReLU network, but some networks may have additional isomorphisms. It is shown in Phuong & Lampert (2019) that there exist ReLU networks of every architecture for which all isomorphisms are given by some combination of permutation and scaling.See also Fefferman (1994) for a proof that an analogous set of isomorphisms is comprehensive for networks with tanh activation. As we demonstrate in §5.2, there exists a positive-measure set of ReLU networks with additional isomorphisms.

In this work, we show that, where additional isomorphisms do not occur, it is in fact often possible both in theory and in practice to reverse-engineer ReLU networks up to permutation and scaling.

2 Linear regions

Throughout this paper, we will make the Linear Regions Assumption: Each region represents a maximal connected component of input space on which the piecewise linear function $\mathcal{N}({\bf x})$ is given by a single linear function. While this assumption has tacitly been made in the prior literature, it is noted in Hanin & Rolnick (2019b) that there are cases where it does not hold. For example, if an entire layer of the network is zeroed out for some inputs, then $\mathcal{N}({\bf x})$ may be given by the same linear function across several adjacent regions, despite these regions corresponding to different ReLU activation patterns.

3 Main result

Let $\mathcal{N}$ be a fully connected ReLU network satisfying the Linear Regions Assumption. Then, the following statement holds except for $\mathcal{N}$ in a measure-zero set of networks: For every neuron $z$, the boundary $B_{z}$ bends exactly where it intersects a boundary $B_{z^{\prime}}$ such that $z^{\prime}$ is in an earlier layer than $z$.

From this theorem, it follows that for any two intersecting boundaries $B_{z}$ and $B_{z^{\prime}}$, one of the following must hold: $B_{z}$ bends at their intersection (in which case $z$ occurs in a deeper layer of the network), $B_{z^{\prime}}$ bends (in which case $z^{\prime}$ occurs in a deeper layer), or neither bends (in which case $z$ and $z^{\prime}$ occur in the same layer). It is not possible for both $B_{z}$ and $B_{z^{\prime}}$ to bend at their intersection – unless that intersection is also contained in another boundary, which is vanishingly unlikely in general. Therefore, the architecture of the network can be determined by evaluating the boundaries $B_{z}$ and where they bend in relation to one another.

In fact, a much stronger statement holds; namely, the weights and biases of the network can also be determined from the boundaries:

Let $\mathcal{N}$ be a fully connected ReLU network satisfying the Linear Regions Assumption. Suppose that for any two neurons $z$ and $z^{\prime}$ that are connected in $\mathcal{N}$, the boundaries $B_{z}$ and $B_{z^{\prime}}$ intersect. Then, given the set of boundaries between linear regions, it is possible to recover both the complete architecture of $\mathcal{N}$ and the weights and biases of every hidden layer, up to permutation and scaling, except for $\mathcal{N}$ in a measure-zero set of networks.

This result follows from Theorem 3, which states that not only is it possible to recover the structure and weights of a network from the boundaries between linear regions, but the boundaries themselves can effectively be approximated by the algorithm we describe in §4, enabling the network to be reverse-engineered merely by querying it. We prove Theorem 3 in Appendix C.

As an intuition for why Theorem 2 holds, observe first that for neurons $z$ in the first layer of the network, the boundaries $B_{z}$ are simply hyperplanes (see Fig. 1). The equations of these hyperplanes reveal the weights from the input to the first layer (up to permutation, scaling, and sign). For each subsequent layer, the weight between neurons $z$ and $z^{\prime}$ can be determined by calculating how $B_{z^{\prime}}$ bends when it crosses $B_{z}$, as this dictates how much the input to $z$ changes when neuron $z^{\prime}$ is zeroed out by its ReLU.

Algorithm

We now describe an algorithm to reverse-engineer a network $\mathcal{N}$ by approximating the boundaries between linear regions. Our algorithm assumes that the output of the network $\mathcal{N}({\bf x})$ can be queried for different inputs ${\bf x}$, but does not assume any a priori knowledge of the linear regions or boundaries.

We begin by identifying the first layer of the network $\mathcal{N}$, for which we must infer the number of neurons, the weight matrix ${\bf W}^{1}$, and the bias vector ${\bf b}^{1}$. As noted above, for each $z=z_{i}^{1}$ in the first layer, the boundary $B_{z}$ is a hyperplane with equation ${\bf W}^{1}_{\cdot i}{\bf x}+{\bf b}^{1}_{i}=0$. For each neuron $z$ in a later layer of the network, the boundary $B_{z}$ will, in general, bend and not be a (full) hyperplane (Theorem 1). We may therefore find the number of neurons in layer 1 by counting the hyperplanes contained in the network’s boundary $B$, and we can infer weights and biases by determining the equations of these hyperplanes.

Inferring hyperplanes. We now fit a hyperplane to each of the boundary points we have identified. For each ${\bf p}\in P_{1}$, there is a neuron $z$ such that ${\bf p}\in B_{z}$. The boundary $B_{z}$ is piecewise linear, with nonlinearities only along other boundaries, and with probability $1$, ${\bf p}$ does not lie on a boundary besides $B_{z}$. Therefore, within a small enough neighborhood of ${\bf p}$, $B_{z}$ is given by a hyperplane, which we call the local hyperplane at ${\bf p}$. If $z$ is in layer 1, then $B_{z}$ equals the local hyperplane. The subroutine InferHyperplane takes as input a point ${\bf p}$ on a boundary $B_{z}$ and approximates the local hyperplane within which ${\bf p}$ lies. This algorithm proceeds by sampling many small line segments around ${\bf p}$, running PointsOnLine to find their points of intersection with $B_{z}$, and performing linear regression to find the equation of the hyperplane containing these points.

Testing hyperplanes. Not all of the hyperplanes we have identified are actually boundaries for neurons in layer 1, so we need to test which hyperplanes are contained in $B$ in their entirety, and which are the local hyperplanes of boundaries that bend. The subroutine TestHyperplane takes as input a point ${\bf p}$ and a hyperplane $H$ containing that point, and determines whether the entire hyperplane $H$ is contained in the boundary $B$ of the network. This algorithm proceeds by sampling points within $H$ that lie far from ${\bf p}$ and applying PointsOnLine to a short line segment around each such point to check whether these points all lie on $B$. Applying TestHyperplane to those hyperplanes inferred in the preceding step allows us to determine those $B_{z}$ for which $z$ is in layer 1.

From hyperplanes to parameters. Finally, we identify the first layer of $\mathcal{N}$ from the equations of hyperplanes contained in $B$. The number of neurons in layer 1 is given simply by the number of distinct $B_{z}$ that are hyperplanes. As we have observed, for $z=z_{i}^{1}$ in layer 1, the hyperplane $B_{z}$ is given by ${\bf W}^{1}_{\cdot i}{\bf x}+{\bf b}^{1}_{i}=0$. We can thus determine ${\bf W}^{1}_{\cdot i}$ and ${\bf b}^{1}_{i}$ up to multiplication by a constant. However, we have already observed that scaling ${\bf W}^{1}_{\cdot i}$ and ${\bf b}^{1}_{i}$ by a positive constant (while inversely scaling ${\bf W}^{2}_{i\cdot}$) is a network isomorphism (§3.1). Therefore, we need only determine the true sign of the multiplicative constant, corresponding to determining which side of the hyperplane is zeroed out by the ReLU. This determination of sign will be performed in §4.2.

2 Additional layers

We now assume that the weights ${\bf W}^{1},\ldots,{\bf W}^{k-1}$ and biases ${\bf b}^{1},\ldots,{\bf b}^{k-1}$ have already been determined within the network $\mathcal{N}$, with the exception of the sign choice for weights and biases at each neuron in layer $k-1$. We now show how it is possible to determine the weights ${\bf W}^{k}$ and biases ${\bf b}^{k}$, along with the correct signs for ${\bf W}^{k-1}$ and ${\bf b}^{k-1}$.

Closest boundary along a line. In this part of our algorithm, we will need the ability to move along a boundary to its intersection with another boundary. For this purpose, the subroutine ClosestBoundary will be useful. It takes as input a point ${\bf p}$, a vector ${\bf v}$ and the network parameters as determined up to layer $k-1$, and outputs the smallest $c>0$ such that ${\bf q}={\bf p}+c{\bf v}$ lies on $B_{z}$ for some $z$ in layer at most $k-1$. In order to compute $c$, we consider the region $R$ within which ${\bf p}$ lies, which is associated with a certain pattern of active and inactive ReLUs. For each boundary $B_{z}$, we calculate the hyperplane equation which would define $B_{z}$ were it to intersect $R$, due to the fixed activation pattern within $R$, and we calculate the distance from ${\bf p}$ to this hyperplane. While not every boundary $B_{z}$ intersects $R$, the closest boundary does, allowing us to find the desired $c$.

Unused boundary points. In order to identify the boundaries $B_{z}$ for $z$ in layer $k$, we wish to identify a set of boundary points with at least one on each such boundary. However, in previous steps of our algorithm, a set $P_{k-1}$ of boundary points was created, of which some were used in ascertaining the parameters of earlier layers. We now consider the subset $P_{k}\subset P_{k-1}$ of points that were not found to belong to $B_{z}$, for $z$ in layers $1$ through $k-1$. These points have already had their local hyperplanes determined.

Exploring boundary intersections. Consider a point ${\bf p}_{1}\in P_{k}$ such that ${\bf p}_{1}\in B_{z}$. Note that $B_{z}$ will, in general, have nonlinearities where it intersects $B_{z^{\prime}}$ such that $z^{\prime}$ lies in an earlier layer than $z$. We explore these intersections, and in particular attempt to find a point of $B_{z}\cap B_{z^{\prime}}$ for every $z^{\prime}$ in layer $k-1$. Given the local hyperplane $H$ at ${\bf p}_{1}$, we pick a direction ${\bf v}$ along $H$ and apply ClosestBoundary to calculate the closest point of intersection ${\bf p}^{\prime}$ with $B_{z^{\prime}}$ for all $z^{\prime}$ already identified in the network. (We discuss below how to pick ${\bf v}$.) Note that if $z$ is in layer $k$, then ${\bf p}^{\prime}$ must be on $B_{z}$ as well as $B_{z^{\prime}}$, while if $z$ is in a later layer of the network, then there may exist unidentified neurons in layers below $z$ and therefore $B_{z}$ may bend before meeting $B_{z^{\prime}}$. We check if ${\bf p}^{\prime}$ lies on $B_{z}$ by applying PointsOnLine, and if so apply InferHyperplane to calculate the local hyperplane of $B_{z}$ on the other side of $B_{z^{\prime}}$ from ${\bf p}_{1}$. We select a representative point ${\bf p}_{2}$ on this local hyperplane. We repeat the process of exploration from the points ${\bf p}_{1},{\bf p}_{2},\ldots$ until one of the following occurs: (i) a point of $B_{z}\cap B_{z^{\prime}}$ has been identified for every $z^{\prime}$ in layer $k-1$ (this may be impossible; see §5.2), (ii) $z$ is determined to be in a layer deeper than $k$ (as a result of ${\bf p}^{\prime}$ not lying on $B_{z}$), or (iii) a maximum number of iterations has been reached.

How to explore. An important step in our algorithm is exploring points of $B_{z}$ that lie on other boundaries. Given a set of points $A_{z}=\{{\bf p}_{1},{\bf p}_{2},\ldots,{\bf p}_{m}\}$ on $B_{z}$, there are several methods for picking a point ${\bf p}_{i}$ and direction ${\bf v}$ along the local hyperplane at ${\bf p}_{i}$ to apply ClosestBoundary. One approach is to pick a random point ${\bf p}_{i}$ from those already identified and a random direction ${\bf v}$; this has the advantage of simplicity. However, it is somewhat faster to consider for which $z^{\prime}$ the intersection $B_{z}\cap B_{z^{\prime}}$ has not yet been identified and attempt specifically to find points on these intersections. One approach for this is to pick a missing $z^{\prime}$ and identify for which ${\bf p}_{i}$ the boundary $B_{z^{\prime}}$ lies on the boundary of the region containing ${\bf p}_{i}$ and solve a linear program to find ${\bf v}$. Another approach is to pick a missing $z^{\prime}$ and a point ${\bf p}_{i}$, calculate the hyperplane $H$ which would describe $B_{z^{\prime}}$ under the activation pattern of ${\bf p}_{i}$, and choose ${\bf v}$ along the local hyperplane to ${\bf p}_{i}$ such that the distance to $H$ is minimized. This is the approach which we take in our implementation, though more sophisticated approaches may exist and present an interesting avenue for further work.

From boundaries to parameters. We now identify layer $k$ of $\mathcal{N}$, along with the sign of the parameters of layer $k-1$, by measuring the extent to which boundaries bend at their intersection. We are also able to identify the correct signs at layer $k-1$ by solving an overconstrained system of constraints capturing the influence of neurons in layer $k-1$ on different regions of input space. Theorem 3 formalizes the inductive step that allows us to go from what we know at layer $k-1$ (weights and biases, up to scaling and sign) to the equivalent set of information for layer $k$.

Discussion

The following theorem (proven in Appendix C) establishes the validity of our algorithm above.

The above algorithm successfully recovers, up to permutation and scaling, the structure and weights of any deep ReLU network for which the assumptions of Theorem 2 hold. No prior knowledge of the weights, structure, or linear region boundaries is assumed, merely the ability to query the network.

Specifically, the following holds true for fully connected ReLU networks $\mathcal{N}$ satisfying the Linear Region Assumption (§3.2), excluding a set of networks with measure zero: Suppose that the weights and biases of $\mathcal{N}$ are known up through layer $k-1$, with the exception that for each neuron in layer $k-1$, the sign of the incoming weights and the bias is unknown. Suppose also that for each $z$ in layer $k$, there exists an ordered set of points $A_{z}=\{{\bf p}_{1},{\bf p}_{2},\ldots,{\bf p}_{m}\}$ such that: (i) Each point lies on the boundary of $B_{z}$, and in (the interior of) a distinct region with respect to the earlier-layer boundaries already known; (ii) each point (except for ${\bf p}_{1}$) has a precursor in an adjacent region; (iii) for each such pair of points, the local hyperplanes of $B_{z}$ are known, as is the boundary $B_{z^{\prime}}$ dividing them ($z^{\prime}$ in an earlier layer); (iv) the set of such $z^{\prime}$ includes all of layer $k-1$.

Then, it is possible to recover the weights and biases for layer $k$, with the exception that for each neuron, the sign of the incoming weights and the bias is unknown. It is also possible to recover the sign for every neuron in layer $k-1$.

Note that even when assumption (iv) of the Theorem is violated, the algorithm recovers the weights corresponding to whichever boundaries are successfully crossed, as we verify empirically in §6.

We expect the number of queries necessary to obtain weights and biases (up to sign) for the first layer should grow as $O(n_{\text{in}}(\sum_{i}n_{i})\log n_{1})$, which for constant-width networks is only slightly above the number of parameters being inferred. Namely, if the biases in the network are bounded above, then each sufficiently long line has constant probability of hitting a given hyperplane, suggesting $\log n_{1}$ lines are required according to a coupon collector-style argument. Hanin & Rolnick (2019a) prove that under natural assumptions, the number of boundary points intersecting a given line through input space grows linearly in the total number of neurons in the network. Finally, each boundary point on a line requires $O(n_{\text{in}})$ queries in order to fit a hyperplane.

For deeper layers, the number of queries depends on the approach taken to explore the intersections between boundaries. It is possible, depending on the arrangement of intersections, for the number of queries to grow linearly in the number of parameters, as each weight can be inferred by examining a single intersection between boundaries.

2 Assumptions

It is possible that for some neurons $z$ and $z^{\prime}$ in consecutive layers, there is no point of intersection between the boundaries $B_{z}$ and $B_{z^{\prime}}$ (or that this intersection is very small), making it impossible to infer the weight between $z$ and $z^{\prime}$ by our algorithm. Some such cases represent an ambiguity in the underlying network – an additional isomorphism to those described in §3.1. Namely, $B_{z}\cap B_{z^{\prime}}$ is empty if one of the following cases holds: (1) whenever $z$ is active, $z^{\prime}$ is inactive; (2) whenever $z$ is active, $z^{\prime}$ is active; (3) whenever $z$ is inactive, $z^{\prime}$ is inactive; or (4) whenever $z$ is inactive, $z^{\prime}$ is active. In case 1, observe that a slight perturbation to the weight $w$ between $z$ and $z^{\prime}$ has no effect upon the network’s output; thus $w$ is not uniquely determined. Cases 2-4 present a more complicated picture; depending on the network, there may or may not be additional isomorphisms.

For simplicity in our algorithm, we have not considered the relatively rare cases where boundaries $B_{z}$ are disconnected or bounded. If $B_{z}$ is disconnected, then it may not be possible to find a connected path along it that intersects all boundaries arising from the preceding layer. In this case, it is simple to infer that two independently identified pieces of the boundary belong to the same neuron to infer the full weight vector. Next, if $B_{z}$ is bounded for some $z$, then it is a closed $(d-1)$-dimensional surface within $d$-dimensional input spaceFor 2D input, such $B_{z}$ must be topological circles, but for higher dimensions, it is conceivable for them to be more complicated surfaces, such as toroidal polyhedra.. While our algorithm requires no modification in this case, bounded $B_{z}$ may be more difficult to find by intersection with randomly chosen lines, and a more principled sampling method may be helpful.

3 Other architectures

While we have expressed our algorithm in terms of multi-layer perceptrons with ReLU activation, it also extends to various other architectures of neural network. Other piecewise linear activation functions admit similar algorithms. For a network with convolutional layers, it is possible to use the same approach to infer the weights between neurons, with two caveats: (i) As we have stated it, the algorithm does not account for weight-sharing – the number of “neurons” in each layer is thus dependent on the input size, and is very large for reasonably sized images. (ii) Pooling layers do affect the partition into activation regions, and indeed introduce new discontinuities into the gradient; our algorithm therefore does not apply.

For skip connections as in ResNets (He et al., 2016), our algorithm should hold with slight modifications, which we outline here. As in a multi-layer perceptron, each boundary component $B_{z}$ is a bent hyperplane that bends when it intersects $B_{z^{\prime}}$ for $z^{\prime}$ at an earlier layer than $z$. However, potential weights must in this case be considered between neurons in any two different layers. Deriving the weights for such skip connections is somewhat more complex than for multi-layer perceptrons, as the “bend” is influenced not merely by the skip connection but by the weights along all other paths between the two neurons through the network. Thus, it is necessary to “move backward” through the network – for a neuron in layer $k$, one must first derive the weights of connections arising from the preceding layer $k-1$, then from $k-2$, and so on.

Experiments

We demonstrate the success of our algorithm on both untrained and trained networks. In keeping with literature on ReLU network initialization (He et al., 2015; Hanin & Rolnick, 2018), networks were initialized using i.i.d. normal weights with variance $2/\text{fan-in}$ and i.i.d. normal biases with unit variance. Networks were trained on either the MNIST dataset ($n_{\text{in}}=784,n_{\text{out}}=10$) or a memorization task of 1000 “datapoints” ($n_{\text{in}}=10,n_{\text{out}}=2$) with coordinates drawn i.i.d. from a unit Gaussian and given arbitrary binary labels. Training was performed using the Adam optimizer (Kingma & Ba, 2014) and a cross-entropy loss applied to the softmax of the final layer, over 20 epochs for MNIST and 1000 epochs for the memorization task. The trained networks (when sufficiently large) were able to attain near-perfect accuracy.

We observe that both the first-layer algorithm and additional-layer algorithm identified weights and biases to within extremely high accuracy (see Figs. 3 and 4). In order to compare estimated and true parameters, we scaled weights at each neuron to unit norm and accounted for possible permutations of the neurons within a layer. (As described in §3.1, these transformations do not change the function computed by the network and represent unavoidable isomorphisms in recovering the network.) Figures show the log normalized error $\log(||\hat{{\bf W}}^{k}-{\bf W}^{k}||_{2}/||\hat{{\bf W}^{k}}||_{2})$ between true weights ${\bf W}^{k}$ and approximated weights $\hat{{\bf W}}^{k}$ and likewise the log normalized error $\log(||\hat{{\bf b}}^{k}-{\bf b}^{k}||_{2}/||\hat{{\bf b}^{k}}||_{2})$ between true biases ${\bf b}^{k}$ and approximated weights $\hat{{\bf b}}^{k}$.

In keeping with our analysis in §5.1, the number of queries needed to recover the first layer of a network scales linearly with the number of neurons in that layer (Fig. 3). In the second layer, a small fraction of weights are sometimes not identified (see §5.2 for a discussion of reasons why such behavior is inevitable); even in such cases, the algorithm is able to correctly predict the remaining parameters (Fig. 4).

Conclusion

In this work, we have proven that it is possible to recover the architecture, weights, and biases of deep ReLU networks from the boundaries between linear regions defined by the network. In many cases, we show that it is possible to reconstruct these boundaries and thus the network itself merely by querying the network’s output on certain inputs. Networks can, we observe, often be reconstructed unambiguously up to permutation of neurons within each layer and scaling of weights and biases at individual neurons. In some cases, there are additional isomorphisms, in which case our algorithm is able to reconstruct a significant fraction of the parameters of the network.

Our approach works for a wide variety of networks, though not all. It is limited to ReLU or otherwise piecewise linear activation functions, though we believe it possible that a continuous version of this method could potentially be developed in future work for use with sigmoidal activation. If used with convolutional layers, our method does not account for the symmetries of the network and therefore scales with the size of the input as well as the number of features, resulting in high computation. Finally, the method is not robust to defenses such as adding noise to the outputs of the network, and therefore can be thwarted by a network designer that seeks to hide their weights/architecture.

We believe that the methods we have introduced here will lead to considerable advances in reverse-engineering neural networks, both in the context of deep learning and, more speculatively, in neuroscience. While the implementation we have demonstrated here is effective in small instances, we anticipate future work that optimizes these methods for efficient use with different architectures and at scale.

References

Appendix A Isomorphism under scaling

Given a fully connected ReLU network $\mathcal{N}$, the network $s_{z,c}(\mathcal{N})$ is isomorphic to $\mathcal{N}$ for every neuron $z$ and constant $c>0$.

Suppose that $z=z_{i}^{k}$ is the $i$th neuron in layer $k$. Then, for each neuron $z_{j}^{k+1}$ in layer $k+1$ of the network $\mathcal{N}$, we have:

By comparison, in network $s_{z,c}(\mathcal{N})$, we have:

where we used the property that $\operatorname{ReLU}(cx)=c\operatorname{ReLU}(x)$ for any $c>0$.

As expressions (1) and (2) are equal, we conclude that $s_{z,c}(\mathcal{N})$ is isomorphic to $\mathcal{N}$.

Appendix B Proof of Theorem 1

It is observed in Hanin & Rolnick (2019b) that $B_{z}$ cannot bend except at points of intersection with $B_{z^{\prime}}$ for $z^{\prime}$ in an earlier layer than $z$. We now prove the converse. Suppose that neurons $z,z^{\prime}$ are such that $z^{\prime}$ lies in an earlier layer than $z$. Consider a point ${\bf p}$ of intersection between $B_{z}$ and $B_{z^{\prime}}$, and suppose that ${\bf p}_{1}$ and ${\bf p}_{2}$ are in an arbitrarily small neighborhood of ${\bf p}$, lying on opposite sides of $B_{z^{\prime}}$. It suffices to prove that $\nabla z({\bf p}_{1})\neq\nabla z({\bf p}_{2})$, and therefore that $B_{z}$ bends as it intersects $B_{z^{\prime}}$.

Appendix C Proof of Theorem 3

In this proof, we will show how the information we are given by the assumptions of the theorem is enough to recover the weights and biases for each neuron $z$ in layer $k$. We will proceed for each $z$ individually, progressively learning weights between $z$ and each of the neurons in the preceding layer (though for skip connections this procedure could also easily be generalized to learn weights from $z$ to earlier layers).

For each of the points ${\bf p}_{i}\in A_{z}$, suppose that $H_{i}$ is the local hyperplane associated with ${\bf p}_{i}$ on boundary $B_{z}$. The gradient $\nabla z({\bf p}_{i})$ at ${\bf p}_{i}$ is orthogonal to $H_{i}$, and we thus already know the direction of the gradient, but its magnitude is unknown to us. We will proceed in order through the points ${\bf p}_{1},{\bf p}_{2},\ldots,{\bf p}_{m}$, with the goal of identifying $\nabla z({\bf p}_{i})$ for each ${\bf p}_{i}$, up to a single scaling factor, as this computation will end up giving us the incoming weights for $z$.

We begin with ${\bf p}_{1}$ by assigning $\nabla z({\bf p}_{1})$ arbitrarily to either one of the two unit vectors orthogonal to $H_{i}$. Due to scaling invariance (Lemma 1), the weights of $\mathcal{N}$ can be rescaled without changing the function so that $\nabla z({\bf p}_{i})$ is multiplied by any positive constant. Therefore, our arbitrary choice can be wrong at most in its sign, and we need not determine the sign at this stage. Now, suppose towards induction that we have identified $\nabla z({\bf p}_{i})$ (up to sign) for $i=1,\ldots,s-1$. We wish to identify $\nabla z({\bf p}_{s})$.

By assumption (ii), there exists a precursor ${\bf p}_{r}$ to ${\bf p}_{s}$ such that $H_{r}$ and $H_{s}$ intersect on a boundary $B_{z^{\prime}}$. Let ${\bf v}_{r}=t_{z}\nabla z({\bf p}_{r})$ be our estimate of $\nabla z({\bf p}_{r})$, for unknown sign $t_{z}\in\{+1,-1\}$. Let ${\bf v}_{s}$ be a unit normal vector to $H_{s}$, so that ${\bf v}_{s}=ct_{z}\nabla z({\bf p}_{s})$ for some unknown constant $c$. We pick the sign of ${\bf v}_{s}$ so that it has the same orientation as ${\bf v}_{r}$ with respect to the surface $B_{z}$, and thus $c>0$. Finally, let ${\bf v}=t_{z^{\prime}}\nabla z^{\prime}({\bf p}_{r})=t_{z^{\prime}}\nabla z^{\prime}({\bf p}_{s})$ be our estimate of the gradient of $z^{\prime}$; where $t_{z^{\prime}}\in\{+1,-1\}$ is also an unknown sign (recall that since $z^{\prime}$ is in layer $k-1$ we know its gradient up to sign). We will use ${\bf v}$ and ${\bf v}_{r}$ to identify ${\bf v}_{s}$.

Suppose that $z=z_{j}^{k}$ is the $j$th neuron in layer $k$ and that $z^{\prime}=z_{h}^{k-1}$ is the $h$th neuron in layer $k-1$. Recall that

As $B_{z^{\prime}}$ is the boundary between inputs for which $z^{\prime}=z_{h}^{k-1}$ is active and inactive, $\operatorname{ReLU}(z_{h}^{k-1}({\bf x})+{\bf b}^{k-1}_{h})$ must equal zero either (Case 1) on $H_{r}$ or (Case 2) on $H_{s}$.

Since we know the vectors ${\bf v}_{s},{\bf v}_{r},{\bf v}$, we are able to deduce the constant $c$.

giving rise to the same value of $c$. We thus may complete our induction. In the process, observe that we have calculated a constant ${\bf W}^{k}_{hj}t_{z}t_{z^{\prime}}t^{\prime}$, where the sign $t^{\prime}$ is $+1$ in Case 1 and $-1$ in Case 2. Note that $t_{z^{\prime}}t^{\prime}$ can be calculated based on whether ${\bf v}$ points towards ${\bf p}_{r}$ or ${\bf p}_{s}$. Therefore, we have obtained ${\bf W}^{k}_{hj}t_{z}$, which is exactly the weight (up to $z$-dependent sign) that we wished to find. Once we have all weights incoming to $z$ (up to sign), it is simple to identify the bias for this neuron (up to sign) by calculating the equation of any known local hyperplane for $B_{z}$ and using the known weights and biases from earlier layers.

To complete the proof, we must now also calculate the correct signs $t_{z^{\prime}}$ of the neurons in layer $k-1$. Pick some $z=z_{j}^{k}$ in layer $k$ and observe that for all points ${\bf p}_{s}\in A_{z}$ there corresponds an equation, obtained by taking gradients in equation (3):

where $\mathds{1}_{i,s}$ equals $1$ if ${\bf p}_{s}$ is on the active side of $B_{z_{i}^{k-1}}$. We can substitute in our (sign-unknown) values for these various quantities:

Now, we may estimate $\mathds{1}_{i,s}$ by a function $\mathds{1}^{\prime}_{i,s}$ that is 1 if ${\bf p}_{s}$ and ${\bf v}_{i}$ are on the same side of $B_{z_{i}^{k-1}}$. This estimate will be wrong exactly when $t_{z_{i}^{k-1}}=-1$. Thus, $\mathds{1}_{i,s}=(1+t_{z_{i}^{k-1}}\mathds{1}^{\prime}_{i,s})/2$, giving us the equation:

All the terms of this equation are known, with the exception of $t_{z}$ and the $n_{k-1}$ variables $t_{z_{i}^{k-1}}$ – giving us a linear system in $n_{k-1}+1$ variables. For a given $z_{j}^{k}$, there are $n_{k-1}$ different ${\bf p}_{s}$ representing the intersections with $B_{z^{\prime}}$ for each $z^{\prime}$ in layer $k-1$; choosing these ${\bf p}_{s}$ should in general give linearly independent constraints. Moreover, the equation is in fact a vector equality with dimension $n_{\text{in}}$; hence, it is a highly overconstrained system, enabling us to identify the signs $t_{z_{i}^{k-1}}$ for each $z_{i}^{k-1}$. This completes the proof of the theorem.