Original: L OCALLY C ONSTANT N ETWORKS
Revised: L OCALLY C ONSTANT N ETWORKS

Original: A BSTRACT
Revised: A BSTRACT

Original: We show how neural models can be used to realize piece
Revised: We show how neural models can be used to realize piece

Original: -wise constant functions such as decision trees
Revised: -wise constant functions such as decision trees

Original: Our approach builds on ReLU networks that are piece
Revised: Our approach builds on ReLU networks that are piece

Original: -wise linear and hence their associated gradients with respect to the inputs are locally constant
Revised: -wise linear and hence their associated gradients with respect to the inputs are locally constant

Original: We formally establish the equivalence between the classes of locally constant networks and decision trees
Revised: We formally establish the equivalence between the classes of locally constant networks and decision trees

Original: Moreover, we highlight several advantageous properties of locally constant networks
Revised: Moreover, we highlight several advantageous properties of locally constant networks

Original: , including how they realize decision trees with parameter sharing across branching
Revised: , including how they realize decision trees with parameter sharing across branching

Original: / leaves
Revised: / leaves

Original: Indeed, only M neurons sufﬁce to implicitly model an oblique decision tree with 2 M leaf nodes.
Revised: Indeed, only M neurons sufﬁce to implicitly model an oblique decision tree with 2 M leaf nodes.

Original: The neural representation also enables us to adopt many tools developed for deep networks
Revised: The neural representation also enables us to adopt many tools developed for deep networks

Original: (e.g
Revised: (e.g

Original: ., DropConnect
Revised: ., DropConnect

Original: (Wan et al.
Revised: (Wan et al.

Original: ) while implicitly training decision trees.
Revised: ) while implicitly training decision trees.

Original: We demonstrate that our method outperforms alternative techniques for training oblique decision trees in the context of molecular property classiﬁcation and regression tasks
Revised: We demonstrate that our method outperforms alternative techniques for training oblique decision trees in the context of molecular property classiﬁcation and regression tasks

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Decision trees (Breiman et al., 1984) employ a series of simple decision nodes, arranged in a tree, to transparently capture how the predicted outcome is reached.
Revised: Decision trees (Breiman et al., 1984) employ a series of simple decision nodes, arranged in a tree, to transparently capture how the predicted outcome is reached.

Original: Functionally, such tree-based models, including random forest (Breiman, 2001), realize piece-wise constant functions.
Revised: Functionally, such tree-based models, including random forest (Breiman, 2001), realize piece-wise constant functions.

Original: Beyond their status as de facto interpretable models, they have also persisted as the state of the art models in some tabular (Sandulescu & Chiru, 2016) and chemical datasets (Wu et al., 2018).
Revised: Beyond their status as de facto interpretable models, they have also persisted as the state of the art models in some tabular (Sandulescu & Chiru, 2016) and chemical datasets (Wu et al., 2018).

Original: Deep neural models, in contrast, are highly ﬂexible and continuous, demonstrably effective in practice, though lack transparency.
Revised: Deep neural models, in contrast, are highly ﬂexible and continuous, demonstrably effective in practice, though lack transparency.

Original: We merge these two contrasting views by introducing a new family of neural models that implicitly learn and represent oblique decision trees.
Revised: We merge these two contrasting views by introducing a new family of neural models that implicitly learn and represent oblique decision trees.

Original: Prior work has attempted to generalize classic decision trees by extending coordinate-wise cuts to be weighted, linear classiﬁcations.
Revised: Prior work has attempted to generalize classic decision trees by extending coordinate-wise cuts to be weighted, linear classiﬁcations.

Original: The resulting family of models is known as oblique decision trees (Murthy et al., 1993).
Revised: The resulting family of models is known as oblique decision trees (Murthy et al., 1993).

Original: However, the generalization accompanies a challenging combinatorial, non-differentiable optimization problem over the linear parameters at each decision point.
Revised: However, the generalization accompanies a challenging combinatorial, non-differentiable optimization problem over the linear parameters at each decision point.

Original: Simple sorting procedures used for successively ﬁnding branch-wise optimal coordinate cuts are no longer available, making these models considerably harder to train.
Revised: Simple sorting procedures used for successively ﬁnding branch-wise optimal coordinate cuts are no longer available, making these models considerably harder to train.

Original: While ﬁnding the optimal oblique decision tree can be cast as a mixed integer linear program (Bertsimas & Dunn, 2017), scaling remains a challenge.
Revised: While ﬁnding the optimal oblique decision tree can be cast as a mixed integer linear program (Bertsimas & Dunn, 2017), scaling remains a challenge.

Original: In this work, we provide an effective, implicit representation of piece-wise constant mappings, termed locally constant networks .
Revised: In this work, we provide an effective, implicit representation of piece-wise constant mappings, termed locally constant networks .

Original: Our approach exploits piece-wise linear models such as ReLU networks as basic building blocks.
Revised: Our approach exploits piece-wise linear models such as ReLU networks as basic building blocks.

Original: Linearity of the mapping in each region in such models means that the gradient with respect to the input coordinates is locally constant.
Revised: Linearity of the mapping in each region in such models means that the gradient with respect to the input coordinates is locally constant.

Original: We therefore implicitly represent piece-wise constant networks through gradients evaluated from ReLU networks.
Revised: We therefore implicitly represent piece-wise constant networks through gradients evaluated from ReLU networks.

Original: We prove the equivalence between the class of oblique decision trees and these proposed locally constant neural models.
Revised: We prove the equivalence between the class of oblique decision trees and these proposed locally constant neural models.

Original: However, the sizes required for equivalent representations can be substantially different.
Revised: However, the sizes required for equivalent representations can be substantially different.

Original: For example, a locally constant network with M neurons can implicitly realize an oblique decision tree whose explicit form requires 2 M − 1 oblique decision nodes.
Revised: For example, a locally constant network with M neurons can implicitly realize an oblique decision tree whose explicit form requires 2 M − 1 oblique decision nodes.

Original: The exponential complexity reduction in the corresponding neural representation illustrates the degree to which parameters are shared across the locally constant regions.
Revised: The exponential complexity reduction in the corresponding neural representation illustrates the degree to which parameters are shared across the locally constant regions.

Original: Our locally constant networks can be learned via gradient descent, and they can be explicitly converted back to oblique decision trees for interpretability.
Revised: Our locally constant networks can be learned via gradient descent, and they can be explicitly converted back to oblique decision trees for interpretability.

Original: For learning via gradient descent, however, it is necessary to employ some smooth annealing of piece-wise linear activation functions so as to keep the gradients themselves continuous.
Revised: For learning via gradient descent, however, it is necessary to employ some smooth annealing of piece-wise linear activation functions so as to keep the gradients themselves continuous.

Original: Moreover, we need to evaluate the gradients of all the neurons with respect to the inputs.
Revised: Moreover, we need to evaluate the gradients of all the neurons with respect to the inputs.

Original: To address this bottleneck, we devise a dynamic programming algorithm which computes all the necessary gradient information in a single forward pass.
Revised: To address this bottleneck, we devise a dynamic programming algorithm which computes all the necessary gradient information in a single forward pass.

Original: A number of extensions are possible.
Revised: A number of extensions are possible.

Original: For instance, we can construct approximately locally constant networks by switching activation functions, or apply helpful techniques used with normal deep learning models (e.g., DropConnect (Wan et al., 2013)) while implicitly training tree models.
Revised: For instance, we can construct approximately locally constant networks by switching activation functions, or apply helpful techniques used with normal deep learning models (e.g., DropConnect (Wan et al., 2013)) while implicitly training tree models.

Original: We empirically test our model in the context of molecular property classiﬁcation and regression tasks (Wu et al., 2018), where tree-based models remain state-of-the-art.
Revised: We empirically test our model in the context of molecular property classiﬁcation and regression tasks (Wu et al., 2018), where tree-based models remain state-of-the-art.

Original: We compare our approach against recent methods for training oblique decision trees and classic ensemble methods such as gradient boosting (Friedman, 2001) and random forest.
Revised: We compare our approach against recent methods for training oblique decision trees and classic ensemble methods such as gradient boosting (Friedman, 2001) and random forest.

Original: Empirically, a locally constant network always outperforms alternative methods for training oblique decision trees by a large margin, and the ensemble of locally constant networks is competitive with classic ensemble methods.
Revised: Empirically, a locally constant network always outperforms alternative methods for training oblique decision trees by a large margin, and the ensemble of locally constant networks is competitive with classic ensemble methods.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Locally constant networks are built on a mixed integer linear representation of piece-wise linear networks, deﬁned as any feed-forward network with a piece-wise linear activation function such as
Revised: Locally constant networks are built on a mixed integer linear representation of piece-wise linear networks, deﬁned as any feed-forward network with a piece-wise linear activation function such as

Original: ReLU (Nair & Hinton, 2010).
Revised: ReLU (Nair & Hinton, 2010).

Original: One can specify a set of integers encoding the active linear piece of each neuron, which is called an activation pattern (Raghu et al., 2017).
Revised: One can specify a set of integers encoding the active linear piece of each neuron, which is called an activation pattern (Raghu et al., 2017).

Original: The feasible set of an activation pattern forms a convex polyhedron in the input space (Lee et al., 2019), where the network degenerates to a linear model.
Revised: The feasible set of an activation pattern forms a convex polyhedron in the input space (Lee et al., 2019), where the network degenerates to a linear model.

Original: The framework motivates us to leverage the locally invariant derivatives of the networks to construct a locally constant network.
Revised: The framework motivates us to leverage the locally invariant derivatives of the networks to construct a locally constant network.

Original: The activation pattern is also exploited in literature for other purposes such as deriving robustness certiﬁcates (Weng et al., 2018).
Revised: The activation pattern is also exploited in literature for other purposes such as deriving robustness certiﬁcates (Weng et al., 2018).

Original: We refer the readers to the recent work (Lee et al., 2019) and the references therein.
Revised: We refer the readers to the recent work (Lee et al., 2019) and the references therein.

Original: Locally constant networks use the gradients of deep networks with respect to inputs as the representations to build discriminative models.
Revised: Locally constant networks use the gradients of deep networks with respect to inputs as the representations to build discriminative models.

Original: Such gradients have been used in literature for different purposes.
Revised: Such gradients have been used in literature for different purposes.

Original: They have been widely used for local sensitivity analysis of trained networks (Simonyan et al., 2013; Smilkov et al., 2017).
Revised: They have been widely used for local sensitivity analysis of trained networks (Simonyan et al., 2013; Smilkov et al., 2017).

Original: When the deep networks model an energy function (LeCun et al., 2006), the gradients can be used to draw samples from the distribution speciﬁed by the normalized energy function (Du & Mordatch, 2019; Song & Ermon, 2019).
Revised: When the deep networks model an energy function (LeCun et al., 2006), the gradients can be used to draw samples from the distribution speciﬁed by the normalized energy function (Du & Mordatch, 2019; Song & Ermon, 2019).

Original: The gradients can also be used to train generative models (Goodfellow et al., 2014) or perform knowledge distillation (Srinivas &
Revised: The gradients can also be used to train generative models (Goodfellow et al., 2014) or perform knowledge distillation (Srinivas &

Original: Fleuret, 2018).
Revised: Fleuret, 2018).

Original: The class of locally constant networks is equivalent to the class of oblique decision trees.
Revised: The class of locally constant networks is equivalent to the class of oblique decision trees.

Original: There are some classic methods that also construct neural networks that reproduce decision trees (Sethi, 1990;
Revised: There are some classic methods that also construct neural networks that reproduce decision trees (Sethi, 1990;

Original: Brent, 1991; Cios & Liu, 1992), by utilizing step functions and logic gates (e.g., AND / NEGATION ) as the activation function.
Revised: Brent, 1991; Cios & Liu, 1992), by utilizing step functions and logic gates (e.g., AND / NEGATION ) as the activation function.

Original: The methods were developed when back-propagation was not yet practically useful, and the motivation is to exploit effective learning procedures of decision trees to train neural networks.
Revised: The methods were developed when back-propagation was not yet practically useful, and the motivation is to exploit effective learning procedures of decision trees to train neural networks.

Original: Instead, our goal is to leverage the successful deep models to train oblique decision trees.
Revised: Instead, our goal is to leverage the successful deep models to train oblique decision trees.

Original: Recently, Yang et al.
Revised: Recently, Yang et al.

Original: (2018) proposed a network architecture with arg max activations to represent classic decision trees with coordinate cuts, but their parameterization scales exponentially with input dimension.
Revised: (2018) proposed a network architecture with arg max activations to represent classic decision trees with coordinate cuts, but their parameterization scales exponentially with input dimension.

Original: In stark contrast, our parameterization only scales linearly with input dimension (see our complexity analyses in § 3.7).
Revised: In stark contrast, our parameterization only scales linearly with input dimension (see our complexity analyses in § 3.7).

Original: Learning oblique decision trees is challenging, even for a greedy algorithm; for a single oblique split, there are at most 2 D ( ND ) different ways to separate N data points in D -dimensional space (Murthy et al., 1993)
Revised: Learning oblique decision trees is challenging, even for a greedy algorithm; for a single oblique split, there are at most 2 D ( ND ) different ways to separate N data points in D -dimensional space (Murthy et al., 1993)

Original: (cf.
Revised: (cf.

Original: ND possibilities for coordinate-cuts).
Revised: ND possibilities for coordinate-cuts).

Original: Existing learning algorithms for oblique decision trees include greedy induction, global optimization, and iterative reﬁnements on an initial tree.
Revised: Existing learning algorithms for oblique decision trees include greedy induction, global optimization, and iterative reﬁnements on an initial tree.

Original: We review some representative works, and refer the readers to the references therein.
Revised: We review some representative works, and refer the readers to the references therein.

Original: Optimizing each oblique split in greedy induction can be realized by coordinate descent (Murthy et al., 1994) or a coordinate-cut search in some linear projection space (Menze et al., 2011; Wickramarachchi et al., 2016).
Revised: Optimizing each oblique split in greedy induction can be realized by coordinate descent (Murthy et al., 1994) or a coordinate-cut search in some linear projection space (Menze et al., 2011; Wickramarachchi et al., 2016).

Original: However, the greedy constructions tend to get stuck in poor local optimum.
Revised: However, the greedy constructions tend to get stuck in poor local optimum.

Original: There are some works which attempt to ﬁnd the global optimum given a ﬁxed tree structure by formulating a linear program (Bennett, 1994) or a mixed integer linear program (Bertsimas & Dunn, 2017), but the methods are not scalable to ordinary tree sizes (e.g., depth more than 4).
Revised: There are some works which attempt to ﬁnd the global optimum given a ﬁxed tree structure by formulating a linear program (Bennett, 1994) or a mixed integer linear program (Bertsimas & Dunn, 2017), but the methods are not scalable to ordinary tree sizes (e.g., depth more than 4).

Original: The itera- tive reﬁnements are more scalable than global optimization, where CART (Breiman et al., 1984) is the typical initialization.
Revised: The itera- tive reﬁnements are more scalable than global optimization, where CART (Breiman et al., 1984) is the typical initialization.

Original: Carreira-Perpin´an & Tavallali (2018) develop an alternating optimization method via iteratively training a linear classiﬁer on each decision node, which yield the state-of-theart empirical performance, but the approach is only applicable to classiﬁcation problems.
Revised: Carreira-Perpin´an & Tavallali (2018) develop an alternating optimization method via iteratively training a linear classiﬁer on each decision node, which yield the state-of-theart empirical performance, but the approach is only applicable to classiﬁcation problems.

Original: Norouzi et al.
Revised: Norouzi et al.

Original: (2015) proposed to do gradient descent on a sub-differentiable upperbound of tree prediction errors, but the gradients with respect to oblique decision nodes are unavailable whenever the upperbound is tight.
Revised: (2015) proposed to do gradient descent on a sub-differentiable upperbound of tree prediction errors, but the gradients with respect to oblique decision nodes are unavailable whenever the upperbound is tight.

Original: In contrast, our method conducts gradient descent on a differentiable relaxation, which is gradually annealed to a locally constant network.
Revised: In contrast, our method conducts gradient descent on a differentiable relaxation, which is gradually annealed to a locally constant network.

Original:  M ETHODOLOGY
Revised:  M ETHODOLOGY

Original: In this section, we introduce the notation and basics in § 3.1, construct the locally constant networks in § 3.2-3.3, analyze the networks in § 3.4-3.5, and develop practical formulations and algorithms in § 3.6-3.7.
Revised: In this section, we introduce the notation and basics in § 3.1, construct the locally constant networks in § 3.2-3.3, analyze the networks in § 3.4-3.5, and develop practical formulations and algorithms in § 3.6-3.7.

Original: Note that we will propose two (equivalent) architectures of locally constant networks in § 3.3 and § 3.6, which are useful for theoretical analyses and practical purposes, respectively.
Revised: Note that we will propose two (equivalent) architectures of locally constant networks in § 3.3 and § 3.6, which are useful for theoretical analyses and practical purposes, respectively.

Original: 3. N OTATION AND BASICS
Revised: 3. N OTATION AND BASICS

Original: The proposed approach is built on feed-forward networks that yield piece-wise linear mappings.
Revised: The proposed approach is built on feed-forward networks that yield piece-wise linear mappings.

Original: Here we ﬁrst introduce a canonical example of such networks, and elaborate its piece-wise linearity.
Revised: Here we ﬁrst introduce a canonical example of such networks, and elaborate its piece-wise linearity.

Original: We consider the densely connected architecture (Huang et al., 2017), where each hidden layer takes as input all the previous layers; it subsumes other existing feed-forward architectures such as residual networks (He et al., 2016).
Revised: We consider the densely connected architecture (Huang et al., 2017), where each hidden layer takes as input all the previous layers; it subsumes other existing feed-forward architectures such as residual networks (He et al., 2016).

Original: For such a network f θ : R D
Revised: For such a network f θ : R D

Original: → R L with the set of parameters θ , we denote the number of hidden layers as M and the number of neurons in the i th layer as N i ; we denote the neurons in the i th layer, before and after activation, as z i ∈
Revised: → R L with the set of parameters θ , we denote the number of hidden layers as M and the number of neurons in the i th layer as N i ; we denote the neurons in the i th layer, before and after activation, as z i ∈

Original: R N i and a i ∈ R N i , respectively, where we sometimes interchangeably denote the input instance x as a 0 ∈ R N 0 with N 0 (cid:44) D .
Revised: R N i and a i ∈ R N i , respectively, where we sometimes interchangeably denote the input instance x as a 0 ∈ R N 0 with N 0 (cid:44) D .

Original: To simplify exposition, we denote the concatenation of ( a 0 , a 1 , . .
Revised: To simplify exposition, we denote the concatenation of ( a 0 , a 1 , . .

Original: . , a i ) as ˜ a i ∈ R ˜ N i with ˜ N i (cid:44) (cid:80) ij =

Revised: . , a i ) as ˜ a i ∈ R ˜ N i with ˜ N i (cid:44) (cid:80) ij =

Original: N i , ∀ i ∈ { 0 , 1 , . . .
Revised: N i , ∀ i ∈ { 0 , 1 , . . .

Original: , M } .
Revised: , M } .

Original: The neurons are deﬁned via the weight matrix
Revised: The neurons are deﬁned via the weight matrix

Original: W i ∈ R N i × ˜ N i −and the bias vector b i ∈ R N i in each layer i ∈
Revised: W i ∈ R N i × ˜ N i −and the bias vector b i ∈ R N i in each layer i ∈

Original: [ M ] (cid:44) { 1 , 2 , . . .
Revised: [ M ] (cid:44) { 1 , 2 , . . .

Original: , M } .
Revised: , M } .

Original: Concretely,
Revised: Concretely,

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: where σ ( · ) is a point-wise activation function.
Revised: where σ ( · ) is a point-wise activation function.

Original: Note that both a and z are functions of the speciﬁc instance denoted by x , where we drop the functional dependency to simplify notation.
Revised: Note that both a and z are functions of the speciﬁc instance denoted by x , where we drop the functional dependency to simplify notation.

Original: We use the set I to denote the set of all the neuron indices in this network { ( i, j ) | j ∈
Revised: We use the set I to denote the set of all the neuron indices in this network { ( i, j ) | j ∈

Original: [ N i ] , i ∈
Revised: [ N i ] , i ∈

Original: [ M ] } .
Revised: [ M ] } .

Original: In this work, we will use ReLU (Nair & Hinton, 2010) as a canonical example for the activation function
Revised: In this work, we will use ReLU (Nair & Hinton, 2010) as a canonical example for the activation function

Original: [Equation]
Revised: [Equation]

Original: but the results naturally generalize to other piece-wise linear activation functions such as leaky
Revised: but the results naturally generalize to other piece-wise linear activation functions such as leaky

Original: ReLU (Maas et al., 2013).
Revised: ReLU (Maas et al., 2013).

Original: The output of the entire network f θ ( x ) is the afﬁne transformation from all the hidden layers ˜ a M with the weight matrix W M +1 ∈ R L × ˜ N M and bias vector b M +1 ∈ R L .
Revised: The output of the entire network f θ ( x ) is the afﬁne transformation from all the hidden layers ˜ a M with the weight matrix W M +1 ∈ R L × ˜ N M and bias vector b M +1 ∈ R L .

Original: 3. L OCAL LINEARITY
Revised: 3. L OCAL LINEARITY

Original: It is widely known that the class of networks f θ ( · ) yields a piece-wise linear function.
Revised: It is widely known that the class of networks f θ ( · ) yields a piece-wise linear function.

Original: The results are typically proved via associating the end-to-end behavior of the network with its activation pattern – which linear piece in each neuron is activated; once an activation pattern is ﬁxed across the entire network, the network degenerates to a linear model and the feasible set with respect to an activation pattern is a natural characterization of a locally linear region of the network.
Revised: The results are typically proved via associating the end-to-end behavior of the network with its activation pattern – which linear piece in each neuron is activated; once an activation pattern is ﬁxed across the entire network, the network degenerates to a linear model and the feasible set with respect to an activation pattern is a natural characterization of a locally linear region of the network.

Original: Formally, we deﬁne the activation pattern as the collection of activation indicator functions for each neuron o ij : R D → { 0 , 1 } , ∀ ( i, j
Revised: Formally, we deﬁne the activation pattern as the collection of activation indicator functions for each neuron o ij : R D → { 0 , 1 } , ∀ ( i, j

Original: ) ∈
Revised: ) ∈

Original: I (or, equivalently, the derivatives of ReLU units; see below) 2 :
Revised: I (or, equivalently, the derivatives of ReLU units; see below) 2 :

Original: [Equation]
Revised: [Equation]

Original: where I [ · ] is the indicator function.
Revised: where I [ · ] is the indicator function.

Original: Note that, for mathematical correctness, we deﬁne ∂ a ij /∂ z ij =at z ij = 0 ; this choice is arbitrary, and one can change it to ∂ a ij /∂
Revised: Note that, for mathematical correctness, we deﬁne ∂ a ij /∂ z ij =at z ij = 0 ; this choice is arbitrary, and one can change it to ∂ a ij /∂

Original: z ij = 0 at z ij = 0 without affecting 𝑥 𝑧 # 𝑎 # 𝑜 # 𝑧 & 𝑎 & 𝑧 ’ 𝑎 ’ 𝑜 & 𝑜 ’ 𝑔 0,0,0 =0 𝑔 0,0,1 = 𝑔 0,1,0 =1 𝑔 0,1,1 = 𝑔 1,0,0 =1 𝑔 1,0,1 = 𝑔 1,1,0 =0 𝑔 1,1,1 =
Revised: z ij = 0 at z ij = 0 without affecting 𝑥 𝑧 # 𝑎 # 𝑜 # 𝑧 & 𝑎 & 𝑧 ’ 𝑎 ’ 𝑜 & 𝑜 ’ 𝑔 0,0,0 =0 𝑔 0,0,1 = 𝑔 0,1,0 =1 𝑔 0,1,1 = 𝑔 1,0,0 =1 𝑔 1,0,1 = 𝑔 1,1,0 =0 𝑔 1,1,1 =

Original: 𝐷𝑒𝑓𝑖𝑛𝑒
Revised: 𝐷𝑒𝑓𝑖𝑛𝑒

Original: True False 𝑧 # ≥ 𝑧 & ≥ 𝑧 ’ ≥ 𝑧 ’ ≥ 𝑧 & ≥ 𝑧 ’ ≥ 𝑧 ’ ≥  100 0≡ ≡ 𝑧 # =
Revised: True False 𝑧 # ≥ 𝑧 & ≥ 𝑧 ’ ≥ 𝑧 ’ ≥ 𝑧 & ≥ 𝑧 ’ ≥ 𝑧 ’ ≥  100 0≡ ≡ 𝑧 # =

Original: 𝑥
Revised: 𝑥

Original: # − 𝑥 & + 1; 𝑧 & =
Revised: # − 𝑥 & + 1; 𝑧 & =

Original: −4𝑥 # + 𝑥 & + 4𝑎 # + 4 ; 𝑧 ’ =
Revised: −4𝑥 # + 𝑥 & + 4𝑎 # + 4 ; 𝑧 ’ =

Original: −𝑥 # + 𝑥 & + 1.5𝑎 # − 0.3𝑎 & − 3.
Revised: −𝑥 # + 𝑥 & + 1.5𝑎 # − 0.3𝑎 & − 3.

Original: Locally constant networks
Revised: Locally constant networks

Original: Decision trees 𝑔 0,0 =0 𝑔 0,1 = 𝑔 1,0 =1 𝑔 1,1 =
Revised: Decision trees 𝑔 0,0 =0 𝑔 0,1 = 𝑔 1,0 =1 𝑔 1,1 =

Original: True False 𝑧 # ≥ 𝑧 & ≥   𝑧 & ≥   ≡ ≡ 𝑔 0 =1 𝑔 1 =
Revised: True False 𝑧 # ≥ 𝑧 & ≥   𝑧 & ≥   ≡ ≡ 𝑔 0 =1 𝑔 1 =

Original: True False 𝑧 # ≥  0 ≡ ≡
Revised: True False 𝑧 # ≥  0 ≡ ≡

Original: Maps 𝑥
Revised: Maps 𝑥

Original: [Figure]
Revised: [Figure]

Original: most of the derivations.
Revised: most of the derivations.

Original: Given a ﬁxed activation pattern ¯ o ij ∈ { 0 , 1 } , ∀ ( i, j ) , we can specify a feasible set in R D that corresponds to this activation pattern { x ∈ R D | o ij = ¯
Revised: Given a ﬁxed activation pattern ¯ o ij ∈ { 0 , 1 } , ∀ ( i, j ) , we can specify a feasible set in R D that corresponds to this activation pattern { x ∈ R D | o ij = ¯

Original: o ij , ∀ ( i, j ) ∈ I} (note that each o ij is a function of x ).
Revised: o ij , ∀ ( i, j ) ∈ I} (note that each o ij is a function of x ).

Original: Due to the ﬁxed activation pattern, the non-linear ReLU can be re-written as a linear function for all the inputs in the feasible set .
Revised: Due to the ﬁxed activation pattern, the non-linear ReLU can be re-written as a linear function for all the inputs in the feasible set .

Original: For example, for an ¯ o ij = 0 , we can re-write a ij = 

Revised: For example, for an ¯ o ij = 0 , we can re-write a ij =

Original: × z ij .
Revised: × z ij .

Original: As a result, the network has a consistent end-to-end linear behavior across the entire feasible set.
Revised: As a result, the network has a consistent end-to-end linear behavior across the entire feasible set.

Original: One can prove that all the feasible sets partition the space R D into disjoint convex polyhedra 3 , which realize a natural representation of the locally linear regions.
Revised: One can prove that all the feasible sets partition the space R D into disjoint convex polyhedra 3 , which realize a natural representation of the locally linear regions.

Original: Since we will only use the result to motivate the construction of locally constant networks, we refer the readers to
Revised: Since we will only use the result to motivate the construction of locally constant networks, we refer the readers to

Original: Lee et al.
Revised: Lee et al.

Original: for a detailed justiﬁcation of the piece-wise linearity of such networks.
Revised: for a detailed justiﬁcation of the piece-wise linearity of such networks.

Original: 3. C ANONICAL LOCALLY CONSTANT NETWORKS
Revised: 3. C ANONICAL LOCALLY CONSTANT NETWORKS

Original: Since the ReLU network f θ ( x ) is piece-wise linear, it immediately implies that its derivatives with respect to the input x is a piece-wise constant function.
Revised: Since the ReLU network f θ ( x ) is piece-wise linear, it immediately implies that its derivatives with respect to the input x is a piece-wise constant function.

Original: Here we use J x f θ ( x ) ∈ R L × D to denote the Jacobian matrix (i.e., [ J x f θ ( x )] i,j = ∂f θ ( x ) i /∂ x j ), and we assume the Jacobian is consistent with Eq.
Revised: Here we use J x f θ ( x ) ∈ R L × D to denote the Jacobian matrix (i.e., [ J x f θ ( x )] i,j = ∂f θ ( x ) i /∂ x j ), and we assume the Jacobian is consistent with Eq.

Original: (3) at the boundary of the locally linear regions.
Revised: (3) at the boundary of the locally linear regions.

Original: Since any function taking the piecewise constant Jacobian as input will remain itself piece-wise constant, we can construct a variety of locally constant networks by composition.
Revised: Since any function taking the piecewise constant Jacobian as input will remain itself piece-wise constant, we can construct a variety of locally constant networks by composition.

Original: However, in order to simplify the derivation, we ﬁrst make a trivial observation that the activation pattern in each locally linear region is also locally invariant.
Revised: However, in order to simplify the derivation, we ﬁrst make a trivial observation that the activation pattern in each locally linear region is also locally invariant.

Original: More broadly, any invariant quantity in each locally linear region can be utilized so as to build locally constant networks.
Revised: More broadly, any invariant quantity in each locally linear region can be utilized so as to build locally constant networks.

Original: We thus deﬁne the locally constant networks as any composite function that leverage the local invariance of piece-wise linear networks.
Revised: We thus deﬁne the locally constant networks as any composite function that leverage the local invariance of piece-wise linear networks.

Original: For the theoretical analyses, we consider the below architecture.
Revised: For the theoretical analyses, we consider the below architecture.

Original: Canonical architecture.
Revised: Canonical architecture.

Original: We denote ˜ o M ∈ { 0 , 1 } ˜ N M as the concatenation of ( o 1 , . . .
Revised: We denote ˜ o M ∈ { 0 , 1 } ˜ N M as the concatenation of ( o 1 , . . .

Original: , o M ) .
Revised: , o M ) .

Original: We will use the composite function g (˜ o M ) as the canonical architecture of locally constant networks for theoretical analyses, where g : { 0 , 1 } ˜ N M
Revised: We will use the composite function g (˜ o M ) as the canonical architecture of locally constant networks for theoretical analyses, where g : { 0 , 1 } ˜ N M

Original: → R L is simply a table.
Revised: → R L is simply a table.

Original: Before elucidating on the representational equivalence to oblique decision trees, we ﬁrst show some toy examples of the canonical locally constant networks and their equivalent mappings in Fig.
Revised: Before elucidating on the representational equivalence to oblique decision trees, we ﬁrst show some toy examples of the canonical locally constant networks and their equivalent mappings in Fig.

Original: 1, which illustrates their constructions when there is only 1 neuron per layer (i.e., z i =
Revised: 1, which illustrates their constructions when there is only 1 neuron per layer (i.e., z i =

Original: z i 1 , and similarly for o i and a i ).
Revised: z i 1 , and similarly for o i and a i ).

Original: When
Revised: When

Original: M = 1 , o 1 = 1 ⇔ x 1 − x 2 + 1 ≥ 0 , thus the locally constant network is equivalent to a linear model shown in the middle, which can also be represented as an oblique decision tree with depth = 1 .
Revised: M = 1 , o 1 = 1 ⇔ x 1 − x 2 + 1 ≥ 0 , thus the locally constant network is equivalent to a linear model shown in the middle, which can also be represented as an oblique decision tree with depth = 1 .

Original: When M > 1 , the activations in the previous layers control different linear behaviors of a neuron with respect to the input, thus realizing a hierarchical structure as an oblique decision tree.
Revised: When M > 1 , the activations in the previous layers control different linear behaviors of a neuron with respect to the input, thus realizing a hierarchical structure as an oblique decision tree.

Original: For example, for M = 2 , o 1 = 0 ⇔ z 1 < 0 ⇒ z 2 = − 4 x 1 + x 2 + 

Revised: For example, for M = 2 , o 1 = 0 ⇔ z 1 < 0 ⇒ z 2 = − 4 x 1 + x 2 +

Original: and o 1 = 1 ⇔ z 1 ≥ 0 ⇒ z
Revised: and o 1 = 1 ⇔ z 1 ≥ 0 ⇒ z

Original: 2 = − 3 x 2 + 8 ; hence, it can also be interpreted as the decision tree on the RHS, where the concrete realization of z 2 depends on the previous decision variable z 1 ≥ 0 .
Revised: 2 = − 3 x 2 + 8 ; hence, it can also be interpreted as the decision tree on the RHS, where the concrete realization of z 2 depends on the previous decision variable z 1 ≥ 0 .

Original: Afterwards, we can map either the activation patterns on the LHS or the decision patterns on the
Revised: Afterwards, we can map either the activation patterns on the LHS or the decision patterns on the

Original: RHS to an output value, which leads to the mapping in the middle.
Revised: RHS to an output value, which leads to the mapping in the middle.

Original: 3. R EPRESENTATIONAL EQUIVALENCE
Revised: 3. R EPRESENTATIONAL EQUIVALENCE

Original: In this section, we prove the equivalence between the class of oblique decision trees and the class of locally constant networks.
Revised: In this section, we prove the equivalence between the class of oblique decision trees and the class of locally constant networks.

Original: We ﬁrst make an observation that any unbalanced oblique decision tree can be re-written to be balanced by adding dummy decision nodes 0 (cid:62) x ≥ − 1 .
Revised: We ﬁrst make an observation that any unbalanced oblique decision tree can be re-written to be balanced by adding dummy decision nodes 0 (cid:62) x ≥ − 1 .

Original: Hence, we can deﬁne the class of oblique decision trees with the balance constraint:
Revised: Hence, we can deﬁne the class of oblique decision trees with the balance constraint:

Original: Deﬁnition 1.
Revised: Deﬁnition 1.

Original: The class of oblique decision trees contains any functions that can be procedurally deﬁned (with some depth T ∈ Z > 0 ) for x ∈ R D :
Revised: The class of oblique decision trees contains any functions that can be procedurally deﬁned (with some depth T ∈ Z > 0 ) for x ∈ R D :

Original: r 1 (cid:44) I [ ω (cid:62) ∅ x + β ∅ ≥ 0] , where ω ∅ ∈ R D and β ∅ ∈ R denote the weight and bias of the root decision node.
Revised: r 1 (cid:44) I [ ω (cid:62) ∅ x + β ∅ ≥ 0] , where ω ∅ ∈ R D and β ∅ ∈ R denote the weight and bias of the root decision node.

Original: For i ∈ (2 , 3 , . .
Revised: For i ∈ (2 , 3 , . .

Original: . , T ) , r i (cid:44) I [ ω (cid:62) r 1: i − 1 x + β r 1: i − 1 ≥ 0] , where ω r 1: i − 1 ∈ R D and β r 1: i − 1 ∈ R denote the weight and bias for the decision node after the decision pattern r 1: i − 1 . 3.
Revised: . , T ) , r i (cid:44) I [ ω (cid:62) r 1: i − 1 x + β r 1: i − 1 ≥ 0] , where ω r 1: i − 1 ∈ R D and β r 1: i − 1 ∈ R denote the weight and bias for the decision node after the decision pattern r 1: i − 1 . 3.

Original: v : { 0 , 1 } T → R L outputs the leaf value v ( r 1: T ) associated with the decision pattern r
Revised: v : { 0 , 1 } T → R L outputs the leaf value v ( r 1: T ) associated with the decision pattern r

Original: 1: T .
Revised: 1: T .

Original: The class of locally constant networks is deﬁned by the canonical architecture with ﬁnite M and
Revised: The class of locally constant networks is deﬁned by the canonical architecture with ﬁnite M and

Original: N i , ∀ i ∈
Revised: N i , ∀ i ∈

Original: [ M ] .
Revised: [ M ] .

Original: We ﬁrst prove that we can represent any oblique decision tree as a locally constant network.
Revised: We ﬁrst prove that we can represent any oblique decision tree as a locally constant network.

Original: Since a typical oblique decision tree can produce an arbitrary weight in each decision node (cf.
Revised: Since a typical oblique decision tree can produce an arbitrary weight in each decision node (cf.

Original: the structurally dependent weights in the oblique decision trees in Fig. 1), the idea is to utilize a network with only 1 hidden layer such that the neurons do not constrain one another.
Revised: the structurally dependent weights in the oblique decision trees in Fig. 1), the idea is to utilize a network with only 1 hidden layer such that the neurons do not constrain one another.

Original: Concretely,
Revised: Concretely,

Original: Theorem 2.
Revised: Theorem 2.

Original: The class of locally constant networks ⊇ the class of oblique decision trees.
Revised: The class of locally constant networks ⊇ the class of oblique decision trees.

Original: Proof.
Revised: Proof.

Original: For any oblique decision tree with depth T , it contains 2 T − 1 weights and biases.
Revised: For any oblique decision tree with depth T , it contains 2 T − 1 weights and biases.

Original: We thus construct a locally constant network with M = 1 and N 1 = 2 T − 1 such that each pair of ( ω , β ) in the oblique decision tree is equal to some W 1 k, : and b 1 k in the constructed locally constant network.
Revised: We thus construct a locally constant network with M = 1 and N 1 = 2 T − 1 such that each pair of ( ω , β ) in the oblique decision tree is equal to some W 1 k, : and b 1 k in the constructed locally constant network.

Original: For each leaf node in the decision tree, it is associated with an output value y ∈ R L and T decisions; the decisions can be written as W 1 idx [ j ] , : x + b 1 idx [ j ] ≥ 0 for j ∈ { 1 , 2 , . . .
Revised: For each leaf node in the decision tree, it is associated with an output value y ∈ R L and T decisions; the decisions can be written as W 1 idx [ j ] , : x + b 1 idx [ j ] ≥ 0 for j ∈ { 1 , 2 , . . .

Original: , T (cid:48) } and W 1 idx [ j ] , : x + b 1 idx [ j ] < 0 for j ∈ { T (cid:48)
Revised: , T (cid:48) } and W 1 idx [ j ] , : x + b 1 idx [ j ] < 0 for j ∈ { T (cid:48)

Original: + 1 , T (cid:48)
Revised: + 1 , T (cid:48)

Original: + 2 , . .
Revised: + 2 , . .

Original: , T } for some index function idx : [ T ] → [2 T − 1] and some T (cid:48) ∈ { 0 , 1 , . . .
Revised: , T } for some index function idx : [ T ] → [2 T − 1] and some T (cid:48) ∈ { 0 , 1 , . . .

Original: , T } .
Revised: , T } .

Original: We can set the table g ( · ) of the locally constant network as y , if (cid:40)
Revised: We can set the table g ( · ) of the locally constant network as y , if (cid:40)

Original: o 1 idx [ j ] = 1( ⇔ W 1 idx [ j ] , : x + b 1 idx [ j ] ≥ 0) , for j ∈ { 1 , 2 , . . .
Revised: o 1 idx [ j ] = 1( ⇔ W 1 idx [ j ] , : x + b 1 idx [ j ] ≥ 0) , for j ∈ { 1 , 2 , . . .

Original: , T (cid:48) } , and o 1 idx [ j ] = 0( ⇔ W 1 idx [ j ] , : x + b 1 idx [ j ] < 0) , for j ∈ { T (cid:48)
Revised: , T (cid:48) } , and o 1 idx [ j ] = 0( ⇔ W 1 idx [ j ] , : x + b 1 idx [ j ] < 0) , for j ∈ { T (cid:48)

Original: + 1 , T (cid:48)
Revised: + 1 , T (cid:48)

Original: + 2 , . .
Revised: + 2 , . .

Original: , T } .
Revised: , T } .

Original: As a result, the constructed locally constant network yields the same output as the given oblique decision tree for all the inputs that are routed to each leaf node, which concludes the proof.
Revised: As a result, the constructed locally constant network yields the same output as the given oblique decision tree for all the inputs that are routed to each leaf node, which concludes the proof.

Original: Then we prove that the class of locally constant networks is a subset of the class of oblique decision trees, which simply follows the construction of the toy examples in Fig.
Revised: Then we prove that the class of locally constant networks is a subset of the class of oblique decision trees, which simply follows the construction of the toy examples in Fig.

Original: Theorem 3.
Revised: Theorem 3.

Original: The class of locally constant networks ⊆
Revised: The class of locally constant networks ⊆

Original: the class of oblique decision trees.
Revised: the class of oblique decision trees.

Original: Proof.
Revised: Proof.

Original: For any locally constant network, it can be re-written to have 1 neuron per layer, by expanding any layer with N i > 1 neurons to be N i different layers such that they do not have effective intra-connections.
Revised: For any locally constant network, it can be re-written to have 1 neuron per layer, by expanding any layer with N i > 1 neurons to be N i different layers such that they do not have effective intra-connections.

Original: Below the notation refers to the converted locally constant network with 1 neuron per layer.
Revised: Below the notation refers to the converted locally constant network with 1 neuron per layer.

Original: We deﬁne the following oblique decision tree with T =
Revised: We deﬁne the following oblique decision tree with T =

Original: M for x ∈ R D :
Revised: M for x ∈ R D :

Original: r 1 (cid:44) o
Revised: r 1 (cid:44) o

Original: 11 =
Revised: 11 =

Original: I [ ω (cid:62) ∅ x + β ∅ ≥ 0] with ω ∅ =
Revised: I [ ω (cid:62) ∅ x + β ∅ ≥ 0] with ω ∅ =

Original: W 11 , : and β ∅ =
Revised: W 11 , : and β ∅ =

Original: b 11 .
Revised: b 11 .

Original: For i ∈ (2 , 3 , . . .
Revised: For i ∈ (2 , 3 , . . .

Original: , M ) , r i (cid:44) I [ ω (cid:62) r 1: i − 1 x + β r 1: i − 1 ≥ 0] , where ω r 1: i − 1 = ∇ x z i 1 and β r 1: i − 

Revised: , M ) , r i (cid:44) I [ ω (cid:62) r 1: i − 1 x + β r 1: i − 1 ≥ 0] , where ω r 1: i − 1 = ∇ x z i 1 and β r 1: i −

Original: =
Revised: =

Original: z i 1 − ( ∇ x z i 1 ) (cid:62) x .
Revised: z i 1 − ( ∇ x z i 1 ) (cid:62) x .

Original: Note that r
Revised: Note that r

Original: i
Revised: i

Original: =
Revised: =

Original: I
Revised: I

Original: [ z i 1 ≥ 0] =
Revised: [ z i 1 ≥ 0] =

Original: o i 1 .
Revised: o i 1 .

Original: v = g .
Revised: v = g .

Original: Note that, in order to be a valid decision tree, ω 1: r i − 1 and β 1: r i − 1 have to be unique for all x that yield the same decision pattern r 1: i − 1 .
Revised: Note that, in order to be a valid decision tree, ω 1: r i − 1 and β 1: r i − 1 have to be unique for all x that yield the same decision pattern r 1: i − 1 .

Original: To see this, for i ∈ (2 , 3 , . .
Revised: To see this, for i ∈ (2 , 3 , . .

Original: . , M ) , as r 1: i − 1 = ( o 11 , . . .
Revised: . , M ) , as r 1: i − 1 = ( o 11 , . . .

Original: , o i − 1 1 ) , we know each z i 1 is a ﬁxed afﬁne function given an activation pattern for the preceding neurons, so ∇ x z i 

Revised: , o i − 1 1 ) , we know each z i 1 is a ﬁxed afﬁne function given an activation pattern for the preceding neurons, so ∇ x z i

Original: and z i 1 − x (cid:62) ∇ x z i 1 are ﬁxed quantities given a decision pattern r 1: i − 1 .
Revised: and z i 1 − x (cid:62) ∇ x z i 1 are ﬁxed quantities given a decision pattern r 1: i − 1 .

Original: Since r 1: M = ˜ o M and v = g , we conclude that they yield the same mapping.
Revised: Since r 1: M = ˜ o M and v = g , we conclude that they yield the same mapping.

Original: Despite the simplicity of the proof, it has some practical implications:
Revised: Despite the simplicity of the proof, it has some practical implications:

Original: Remark 4.
Revised: Remark 4.

Original: The proof of Theorem 3 implies that we can train a locally constant network with M neurons, and convert it to an oblique decision tree with depth M (for interpretability).
Revised: The proof of Theorem 3 implies that we can train a locally constant network with M neurons, and convert it to an oblique decision tree with depth M (for interpretability).

Original: Remark 5.
Revised: Remark 5.

Original: The proof of Theorem 3 establishes that, given a ﬁxed number of neurons, it sufﬁces (representationally) to only consider the locally constant networks with one neuron per layer.
Revised: The proof of Theorem 3 establishes that, given a ﬁxed number of neurons, it sufﬁces (representationally) to only consider the locally constant networks with one neuron per layer.

Original: Remark 5 is important for learning small locally constant networks (which can be converted to shallow decision trees for interpretability), since representation capacity is critical for low capacity models.
Revised: Remark 5 is important for learning small locally constant networks (which can be converted to shallow decision trees for interpretability), since representation capacity is critical for low capacity models.

Original: In the remainder of the paper, we will only consider the setting with N i = 1 , ∀ i ∈
Revised: In the remainder of the paper, we will only consider the setting with N i = 1 , ∀ i ∈

Original: [ M ] .
Revised: [ M ] .

Original: 3. S TRUCTURALLY SHARED PARAMETERIZATION
Revised: 3. S TRUCTURALLY SHARED PARAMETERIZATION

Original: Although we have established the exact class-level equivalence between locally constant networks and oblique decision trees, once we restrict the depth of the locally constant networks M , it can no longer re-produce all the decision trees with depth M .
Revised: Although we have established the exact class-level equivalence between locally constant networks and oblique decision trees, once we restrict the depth of the locally constant networks M , it can no longer re-produce all the decision trees with depth M .

Original: The result can be intuitively understood by the following reason: we are effectively using M pairs of (weight, bias) in the locally constant network to implicitly realize 2 M − 1 pairs of (weight, bias) in the corresponding oblique decision tree.
Revised: The result can be intuitively understood by the following reason: we are effectively using M pairs of (weight, bias) in the locally constant network to implicitly realize 2 M − 1 pairs of (weight, bias) in the corresponding oblique decision tree.

Original: Such exponential reduction on the effective parameters in the representation of oblique decision trees yields “dimension reduction” of the model capacity.
Revised: Such exponential reduction on the effective parameters in the representation of oblique decision trees yields “dimension reduction” of the model capacity.

Original: This section aims to reveal the implied shared parameterization embedded in the oblique decision trees derived from locally constant networks.
Revised: This section aims to reveal the implied shared parameterization embedded in the oblique decision trees derived from locally constant networks.

Original: In this section, the oblique decision trees and the associated parameters refer to the decision trees obtained via the proof of Theorem 3 .
Revised: In this section, the oblique decision trees and the associated parameters refer to the decision trees obtained via the proof of Theorem 3 .

Original: We start the analysis by a decomposition of ω r 1: i among the preceding weights ω ∅ , ω r 1:1 , . . .
Revised: We start the analysis by a decomposition of ω r 1: i among the preceding weights ω ∅ , ω r 1:1 , . . .

Original: , ω r 1: r − 1 .
Revised: , ω r 1: r − 1 .

Original: To simplify notation, we denote ω r 1:0 (cid:44) ω ∅ .
Revised: To simplify notation, we denote ω r 1:0 (cid:44) ω ∅ .

Original: Since ω r 1: i = ∇ x z i + and z i + is an afﬁne transformation of the vector ( a 0 , a 11 , . .
Revised: Since ω r 1: i = ∇ x z i + and z i + is an afﬁne transformation of the vector ( a 0 , a 11 , . .

Original: . , a i 1 ) ,
Revised: . , a i 1 ) ,

Original: ω
Revised: ω

Original: [Equation]
Revised: [Equation]

Original: where we simply re-write the derivatives in terms of tree parameters.
Revised: where we simply re-write the derivatives in terms of tree parameters.

Original: Since W i +11 , 1: D is ﬁxed for all the ω r 1: i , the above decomposition implies that, in the induced tree, all the weights ω r 1: i in the same depth i are restricted to be a linear combination of the ﬁxed basis W i +11 , 1: D and the corresponding preceding weights ω r 1:0 , . . .
Revised: Since W i +11 , 1: D is ﬁxed for all the ω r 1: i , the above decomposition implies that, in the induced tree, all the weights ω r 1: i in the same depth i are restricted to be a linear combination of the ﬁxed basis W i +11 , 1: D and the corresponding preceding weights ω r 1:0 , . . .

Original: , ω r 1: i − 1 .We can extend this analysis to compare weights in same layer, and we begin the analysis by comparing weights whose (cid:96) 0 distance in decision pattern is 1 .
Revised: , ω r 1: i − 1 .We can extend this analysis to compare weights in same layer, and we begin the analysis by comparing weights whose (cid:96) 0 distance in decision pattern is 1 .

Original: To help interpret the statement, note that ω r 1: j − 1 is the weight that leads to the decision r j (or r (cid:48)
Revised: To help interpret the statement, note that ω r 1: j − 1 is the weight that leads to the decision r j (or r (cid:48)

Original: j ; see below).
Revised: j ; see below).

Original: Lemma 6.
Revised: Lemma 6.

Original: For an oblique decision tree with depth T > 1 , ∀ i ∈
Revised: For an oblique decision tree with depth T > 1 , ∀ i ∈

Original: [ T − 1] and any r 1: i , r (cid:48) 1: i such that r k
Revised: [ T − 1] and any r 1: i , r (cid:48) 1: i such that r k

Original: =
Revised: =

Original: r
Revised: r

Original: (cid:48)
Revised: (cid:48)

Original: k for all k ∈
Revised: k for all k ∈

Original: [ i ] except that r j (cid:54) =
Revised: [ i ] except that r j (cid:54) =

Original: r (cid:48)
Revised: r (cid:48)

Original: j for some j ∈ [ i ] , we have
Revised: j for some j ∈ [ i ] , we have

Original: [Equation]
Revised: [Equation]

Original: The proof involves some algebraic manipulation, and is deferred to Appendix A.1.
Revised: The proof involves some algebraic manipulation, and is deferred to Appendix A.1.

Original: Lemma 6 characterizes an interesting structural constraint embedded in the oblique decision trees realized by locally constant networks, where the structural discrepancy r j in decision patterns ( r 1: i versus r (cid:48) 1: i ) is reﬂected on the discrepancy of the corresponding weights (up to a scaling factor α ).
Revised: Lemma 6 characterizes an interesting structural constraint embedded in the oblique decision trees realized by locally constant networks, where the structural discrepancy r j in decision patterns ( r 1: i versus r (cid:48) 1: i ) is reﬂected on the discrepancy of the corresponding weights (up to a scaling factor α ).

Original: The analysis can be generalized for all the weights in the same layer, but the message is similar.
Revised: The analysis can be generalized for all the weights in the same layer, but the message is similar.

Original: Proposition 7.
Revised: Proposition 7.

Original: For the oblique decision tree with depth T > 1 , ∀ i ∈
Revised: For the oblique decision tree with depth T > 1 , ∀ i ∈

Original: [ T − 1] and any r 1: i , r (cid:48) 1: i such that r k
Revised: [ T − 1] and any r 1: i , r (cid:48) 1: i such that r k

Original: =
Revised: =

Original: r
Revised: r

Original: (cid:48)
Revised: (cid:48)

Original: k for all k ∈
Revised: k for all k ∈

Original: [ i ] except for n ∈
Revised: [ i ] except for n ∈

Original: [ i ] coordinates j 1 , . .
Revised: [ i ] coordinates j 1 , . .

Original: . , j n ∈ [ i ] , we have
Revised: . , j n ∈ [ i ] , we have

Original: [Equation]
Revised: [Equation]

Original: R
Revised: R

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: [Equation]
Revised: [Equation]

Original: The statement can be proved by applying Lemma 6 multiple times.
Revised: The statement can be proved by applying Lemma 6 multiple times.

Original: Discussion.
Revised: Discussion.

Original: Here we summarize this section and provide some discussion.
Revised: Here we summarize this section and provide some discussion.

Original: Locally constant networks implicitly represent oblique decision trees with the same depth and structurally shared parameterization.
Revised: Locally constant networks implicitly represent oblique decision trees with the same depth and structurally shared parameterization.

Original: In the implied oblique decision trees, the weight of each decision node is a linear combination of a shared weight across the whole layer and all the preceding weights.
Revised: In the implied oblique decision trees, the weight of each decision node is a linear combination of a shared weight across the whole layer and all the preceding weights.

Original: The analysis explains how locally constant networks use only M weights to model a decision tree with 2 M −decision nodes; it yields a strong regularization effect to avoid overﬁtting, and helps computation by exponentially reducing the memory consumption on the weights.
Revised: The analysis explains how locally constant networks use only M weights to model a decision tree with 2 M −decision nodes; it yields a strong regularization effect to avoid overﬁtting, and helps computation by exponentially reducing the memory consumption on the weights.

Original: 3. S TANDARD LOCALLY CONSTANT NETWORKS AND EXTENSIONS
Revised: 3. S TANDARD LOCALLY CONSTANT NETWORKS AND EXTENSIONS

Original: The simple structure of the canonical locally constant networks is beneﬁcial for theoretical analysis, but the structure is not practical for learning since the discrete activation pattern does not exhibit gradients for learning the networks.
Revised: The simple structure of the canonical locally constant networks is beneﬁcial for theoretical analysis, but the structure is not practical for learning since the discrete activation pattern does not exhibit gradients for learning the networks.

Original: Indeed, ∇ ˜ o M g
Revised: Indeed, ∇ ˜ o M g

Original: (˜ o M ) is undeﬁned, which implies that ∇ W i g (˜ o M ) is also undeﬁned.
Revised: (˜ o M ) is undeﬁned, which implies that ∇ W i g (˜ o M ) is also undeﬁned.

Original: Here we present another architecture that is equivalent to the canonical architecture, but exhibits sub-gradients with respect to model parameters and is ﬂexible for model extension.
Revised: Here we present another architecture that is equivalent to the canonical architecture, but exhibits sub-gradients with respect to model parameters and is ﬂexible for model extension.

Original: Standard architecture.
Revised: Standard architecture.

Original: We assume N i
Revised: We assume N i

Original: = 1 , ∀ i ∈
Revised: = 1 , ∀ i ∈

Original: [ M ] .
Revised: [ M ] .

Original: We denote the Jacobian of all the neurons after activation ˜ a M as J x ˜ a M ∈ R M × D , and denote (cid:126)J x ˜ a M as the vectorized version.
Revised: We denote the Jacobian of all the neurons after activation ˜ a M as J x ˜ a M ∈ R M × D , and denote (cid:126)J x ˜ a M as the vectorized version.

Original: We then deﬁne the standard architecture as g φ ( (cid:126) J x ˜ a M ) , where g φ : R ( M × D ) → R L is a fully-connected network.
Revised: We then deﬁne the standard architecture as g φ ( (cid:126) J x ˜ a M ) , where g φ : R ( M × D ) → R L is a fully-connected network.

Original: We abbreviate the standard locally constant networks as L CN .
Revised: We abbreviate the standard locally constant networks as L CN .

Original: Note that each a i 1 is locally linear and thus the Jacobian J x ˜ a M is locally constant.
Revised: Note that each a i 1 is locally linear and thus the Jacobian J x ˜ a M is locally constant.

Original: We replace ˜ o
Revised: We replace ˜ o

Original: M with J x ˜ a M as the invariant representation for each locally linear region 4 , and replace the table g with a differentiable function g φ that takes as input real vectors.
Revised: M with J x ˜ a M as the invariant representation for each locally linear region 4 , and replace the table g with a differentiable function g φ that takes as input real vectors.

Original: The gradients of L CN with respect to parameters is thus established through the derivatives of g φ and the mixed partial derivatives of the neurons (derivatives of (cid:126)J x ˜ a M ).
Revised: The gradients of L CN with respect to parameters is thus established through the derivatives of g φ and the mixed partial derivatives of the neurons (derivatives of (cid:126)J x ˜ a M ).

Original: Fortunately, all the previous analyses also apply to the standard architecture, due to a ﬁne-grained equivalence between the two architectures.
Revised: Fortunately, all the previous analyses also apply to the standard architecture, due to a ﬁne-grained equivalence between the two architectures.

Original: Theorem 8.
Revised: Theorem 8.

Original: Given any ﬁxed f θ , any canonical locally constant network g (˜ o M ) can be equivalently represented by a standard locally constant network g φ ( (cid:126)J x ˜ a M ) , and vice versa.
Revised: Given any ﬁxed f θ , any canonical locally constant network g (˜ o M ) can be equivalently represented by a standard locally constant network g φ ( (cid:126)J x ˜ a M ) , and vice versa.

Original: Since f θ and g control the decision nodes and leaf nodes in the associated oblique decision tree, respectively (see Theorem 3), Theorem 8 essentially states that both architectures are equally competent for assigning leaf nodes.
Revised: Since f θ and g control the decision nodes and leaf nodes in the associated oblique decision tree, respectively (see Theorem 3), Theorem 8 essentially states that both architectures are equally competent for assigning leaf nodes.

Original: Combining Theorem 8 with the analyses in § 3.4, we have class-level equivalence among the two architectures of locally constant networks and oblique decision trees.
Revised: Combining Theorem 8 with the analyses in § 3.4, we have class-level equivalence among the two architectures of locally constant networks and oblique decision trees.

Original: The analyses in § 3.5 are also inherited since the analyses only depend on decision nodes (i.e., f θ ).
Revised: The analyses in § 3.5 are also inherited since the analyses only depend on decision nodes (i.e., f θ ).

Original: The core ideas for proving Theorem 8 are two-fold: 1) we ﬁnd a bijection between the activation pattern ˜
Revised: The core ideas for proving Theorem 8 are two-fold: 1) we ﬁnd a bijection between the activation pattern ˜

Original: o M and the Jacobian (cid:126)J x ˜ a M , and 2) feed-forward networks g φ can map the (ﬁnitely many)
Revised: o M and the Jacobian (cid:126)J x ˜ a M , and 2) feed-forward networks g φ can map the (ﬁnitely many)

Original: Jacobian (cid:126)J x ˜ a M as ﬂexibly as a table g .
Revised: Jacobian (cid:126)J x ˜ a M as ﬂexibly as a table g .

Original: The complete proof is deferred to Appendix A.2.
Revised: The complete proof is deferred to Appendix A.2.

Original: Discussion.
Revised: Discussion.

Original: The standard architecture yields a new property that is only partially exhibited in the canonical architecture.
Revised: The standard architecture yields a new property that is only partially exhibited in the canonical architecture.

Original: For all the decision and leaf nodes which no training data is routed to, there is no way to obtain learning signals in classic oblique decision trees.
Revised: For all the decision and leaf nodes which no training data is routed to, there is no way to obtain learning signals in classic oblique decision trees.

Original: However, due to shared parameterization (see § 3.5), locally constant networks can “learn” all the decision nodes in the implied oblique decision trees (if there is a way to optimize the networks), and the standard architecture can even “learn” all the leaf nodes due to the parameterized output function g φ .
Revised: However, due to shared parameterization (see § 3.5), locally constant networks can “learn” all the decision nodes in the implied oblique decision trees (if there is a way to optimize the networks), and the standard architecture can even “learn” all the leaf nodes due to the parameterized output function g φ .

Original: Extensions.
Revised: Extensions.

Original: The construction of (standard) locally constant networks enables several natural extensions due to the ﬂexibility of the neural architecture and the interpretation of decision trees.
Revised: The construction of (standard) locally constant networks enables several natural extensions due to the ﬂexibility of the neural architecture and the interpretation of decision trees.

Original: The original locally linear networks ( L LN )
Revised: The original locally linear networks ( L LN )

Original: f θ , which outputs a linear function instead of a constant function for each region, can be regarded as one extension.
Revised: f θ , which outputs a linear function instead of a constant function for each region, can be regarded as one extension.

Original: Here we discuss two examples.
Revised: Here we discuss two examples.

Original: • Approximately locally constant networks ( A LCN ): we can change the activation function while keeping the model architecture of L CN .
Revised: • Approximately locally constant networks ( A LCN ): we can change the activation function while keeping the model architecture of L CN .

Original: For example, we can replace ReLU max(0 , x ) with softplus log(1 + exp( x )) , which will lead to an approximately locally constant network, as the softplus function has an approximately locally constant derivative for inputs with large absolute value.
Revised: For example, we can replace ReLU max(0 , x ) with softplus log(1 + exp( x )) , which will lead to an approximately locally constant network, as the softplus function has an approximately locally constant derivative for inputs with large absolute value.

Original: Note that the canonical architecture (tabular g ) is not compatible with such extension.
Revised: Note that the canonical architecture (tabular g ) is not compatible with such extension.

Original: • Ensemble locally constant networks ( E LCN ): since each L CN can only output 2 M different values, it is limited for complex tasks like regression (akin to decision trees).
Revised: • Ensemble locally constant networks ( E LCN ): since each L CN can only output 2 M different values, it is limited for complex tasks like regression (akin to decision trees).

Original: We can instead use an
Revised: We can instead use an

Original: additive ensemble of L CN or A LCN to increase the capacity.
Revised: additive ensemble of L CN or A LCN to increase the capacity.

Original: We use g [ e ] φ ( (cid:126)J x ˜ a M, [ e ] ) to denote a base model in the ensemble, and denote the ensemble with E models as (cid:80) Ee =1 g [ e ] φ ( (cid:126)J x ˜ a M, [ e ] ) .
Revised: We use g [ e ] φ ( (cid:126)J x ˜ a M, [ e ] ) to denote a base model in the ensemble, and denote the ensemble with E models as (cid:80) Ee =1 g [ e ] φ ( (cid:126)J x ˜ a M, [ e ] ) .

Original: 3. C OMPUTATION AND LEARNING
Revised: 3. C OMPUTATION AND LEARNING

Original: In this section, we discuss computation and learning algorithms for the proposed models.
Revised: In this section, we discuss computation and learning algorithms for the proposed models.

Original: In the following complexity analyses, we assume g φ to be a linear model.
Revised: In the following complexity analyses, we assume g φ to be a linear model.

Original: Space complexity.
Revised: Space complexity.

Original: The space complexity of L CN is Θ( MD ) for representing decision nodes and Θ( MDL ) for representing leaf nodes.
Revised: The space complexity of L CN is Θ( MD ) for representing decision nodes and Θ( MDL ) for representing leaf nodes.

Original: In contrast, the space complexity of classic oblique decision trees is Θ((2 M − 1) D ) for decision nodes and Θ(2 M L ) for leaf nodes.
Revised: In contrast, the space complexity of classic oblique decision trees is Θ((2 M − 1) D ) for decision nodes and Θ(2 M L ) for leaf nodes.

Original: Hence, our representation improves the space complexity over classic oblique decision trees exponentially.
Revised: Hence, our representation improves the space complexity over classic oblique decision trees exponentially.

Original: Computation and time complexity.
Revised: Computation and time complexity.

Original: L CN and A LCN are built on the gradients of all the neurons (cid:126)J x ˜ a M =
Revised: L CN and A LCN are built on the gradients of all the neurons (cid:126)J x ˜ a M =

Original: [ ∇ x a M 1 , . . . , ∇ x a 11 ] , which can be computationally challenging to obtain.
Revised: [ ∇ x a M 1 , . . . , ∇ x a 11 ] , which can be computationally challenging to obtain.

Original: Existing automatic differentiation (e.g., back-propagation) only computes the gradient of a scalar output.
Revised: Existing automatic differentiation (e.g., back-propagation) only computes the gradient of a scalar output.

Original: Instead, here we propose an efﬁcient dynamic programming procedure which only requires a forward pass:
Revised: Instead, here we propose an efﬁcient dynamic programming procedure which only requires a forward pass:

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: The complexity of the dynamic programming is Θ( M 2 ) due to the inner-summation inside each iteration.
Revised: The complexity of the dynamic programming is Θ( M 2 ) due to the inner-summation inside each iteration.

Original: Straightforward back-propagation re-computes the partial solutions ∇ x a k 1 for each ∇ x a i 1 , so the complexity is Θ( M 3 ) .
Revised: Straightforward back-propagation re-computes the partial solutions ∇ x a k 1 for each ∇ x a i 1 , so the complexity is Θ( M 3 ) .

Original: We can parallelize the inner-summation on a GPU, and the complexity of the dynamic programming and straightforward back-propagation will become Θ( M ) and Θ( M 2 ) , respectively.
Revised: We can parallelize the inner-summation on a GPU, and the complexity of the dynamic programming and straightforward back-propagation will become Θ( M ) and Θ( M 2 ) , respectively.

Original: Note that the complexity of a forward pass of a typical network is also Θ( M ) on a
Revised: Note that the complexity of a forward pass of a typical network is also Θ( M ) on a

Original: GPU.
Revised: GPU.

Original: The time complexity of learning L CN by (stochastic) gradient descent is thus Θ( Mτ ) , where τ denotes the number of iterations.
Revised: The time complexity of learning L CN by (stochastic) gradient descent is thus Θ( Mτ ) , where τ denotes the number of iterations.

Original: In contrast, the computation of existing oblique decision tree training algorithms is typically data-dependent and thus the complexity is hard to characterize.
Revised: In contrast, the computation of existing oblique decision tree training algorithms is typically data-dependent and thus the complexity is hard to characterize.

Original: Training L CN and A LCN .
Revised: Training L CN and A LCN .

Original: Even though L CN is sub-differentiable, whenever o i 1 = 0 , the network does not exhibit useful gradient information for learning each locally constant representation ∇ x a i(note that (cid:126)J x ˜ a M =
Revised: Even though L CN is sub-differentiable, whenever o i 1 = 0 , the network does not exhibit useful gradient information for learning each locally constant representation ∇ x a i(note that (cid:126)J x ˜ a M =

Original: [ ∇ x a 11 , . . . , ∇ x a M 1 ] ), since, operationally, o i 1 = 0 implies a i 1 ← 

Revised: [ ∇ x a 11 , . . . , ∇ x a M 1 ] ), since, operationally, o i 1 = 0 implies a i 1 ←

Original: and there is no useful gradient of ∇ x a i 1 = ∇ x 0 = 0 with respect to model parameters.
Revised: and there is no useful gradient of ∇ x a i 1 = ∇ x 0 = 0 with respect to model parameters.

Original: To alleviate the problem, we propose to leverage softplus as an inﬁnitely differentiable approximation of ReLU to obtain meaningful learning signals for ∇ x a i 1 .
Revised: To alleviate the problem, we propose to leverage softplus as an inﬁnitely differentiable approximation of ReLU to obtain meaningful learning signals for ∇ x a i 1 .

Original: Concretely, we conduct the annealing during training:
Revised: Concretely, we conduct the annealing during training:

Original: [Equation]
Revised: [Equation]

Original: where λ t is an iteration-dependent annealing parameter.
Revised: where λ t is an iteration-dependent annealing parameter.

Original: Both L CN and A LCN can be constructed as a special case of Eq.
Revised: Both L CN and A LCN can be constructed as a special case of Eq.

Original: We train L CN with λ t equal to the ratio between the current epoch and the total epochs, and A LCN with λ t = 0 .
Revised: We train L CN with λ t equal to the ratio between the current epoch and the total epochs, and A LCN with λ t = 0 .

Original: Both models are optimized via stochastic gradient descent.
Revised: Both models are optimized via stochastic gradient descent.

Original: We also include DropConnect (Wan et al., 2013) to the weight matrices
Revised: We also include DropConnect (Wan et al., 2013) to the weight matrices

Original: W i ← drop ( W i ) during training.
Revised: W i ← drop ( W i ) during training.

Original: Despite the simple structure of DropConnect in the locally constant networks, it entails a structural dropout on the weights in the corresponding oblique decision trees (see § 3.5), which is challenging to reproduce in typical oblique decision trees.
Revised: Despite the simple structure of DropConnect in the locally constant networks, it entails a structural dropout on the weights in the corresponding oblique decision trees (see § 3.5), which is challenging to reproduce in typical oblique decision trees.

Original: In addition, it also encourages the exploration of parameter space, which is easy to see for the raw L CN : the randomization enables the exploration that ﬂips o i 1 = 0 to o i 1 = 1 to establish effective learning signal.
Revised: In addition, it also encourages the exploration of parameter space, which is easy to see for the raw L CN : the randomization enables the exploration that ﬂips o i 1 = 0 to o i 1 = 1 to establish effective learning signal.

Original: Note that the standard
Revised: Note that the standard

Original: DropOut (Srivastava et al., 2014) is not ideal for the low capacity models that we consider here.
Revised: DropOut (Srivastava et al., 2014) is not ideal for the low capacity models that we consider here.

Original: Training E LCN .
Revised: Training E LCN .

Original: Since each ensemble component is sub-differentiable, we can directly learn the whole ensemble through gradient descent.
Revised: Since each ensemble component is sub-differentiable, we can directly learn the whole ensemble through gradient descent.

Original: However, the approach is not scalable due to memory constraints in practice.
Revised: However, the approach is not scalable due to memory constraints in practice.

Original: Instead, we propose to train the ensemble in a boosting fashion:
Revised: Instead, we propose to train the ensemble in a boosting fashion:

Original: We
Revised: We

Original: ﬁrst train an initial locally constant network g [1] φ ( (cid:126)J x ˜ a M, [1] ) .
Revised: ﬁrst train an initial locally constant network g [1] φ ( (cid:126)J x ˜ a M, [1] ) .

Original: For each iteration e (cid:48) ∈ { 2 , 3 , . . .
Revised: For each iteration e (cid:48) ∈ { 2 , 3 , . . .

Original: , E } , we incrementally optimize (cid:80) e (cid:48)
Revised: , E } , we incrementally optimize (cid:80) e (cid:48)

Original: e =1 g [ e ] φ ( (cid:126)J x ˜ a M, [ e ] ) .
Revised: e =1 g [ e ] φ ( (cid:126)J x ˜ a M, [ e ] ) .

Original: Note that, in the second step, only the latest model is optimized, and thus we can simply store the predictions of the preceding models without loading them into the memory.
Revised: Note that, in the second step, only the latest model is optimized, and thus we can simply store the predictions of the preceding models without loading them into the memory.

Original: Each partial ensemble can be directly learned through gradient descent, without resorting to complex meta-algorithms such as adaptive boosting (Freund & Schapire, 1997) or gradient boosting (Friedman, 2001).
Revised: Each partial ensemble can be directly learned through gradient descent, without resorting to complex meta-algorithms such as adaptive boosting (Freund & Schapire, 1997) or gradient boosting (Friedman, 2001).

Original: [Table] [Table]
Revised: [Table] [Table]

Original:  E XPERIMENT
Revised:  E XPERIMENT

Original: Here we evaluate the efﬁcacy of our models (L CN , A LCN , and E LCN ) using the chemical property prediction datasets from MoleculeNet (Wu et al., 2018), where random forest performs competitively.
Revised: Here we evaluate the efﬁcacy of our models (L CN , A LCN , and E LCN ) using the chemical property prediction datasets from MoleculeNet (Wu et al., 2018) [Table] where random forest performs competitively.

Original: We include 4 (multi-label) binary classiﬁcation datasets and 1 regression dataset.
Revised: We include 4 (multi-label) binary classiﬁcation datasets and 1 regression dataset.

Original: The statistics are available in Table 1.
Revised: The statistics are available in Table 1.

Original: We follow the literature to construct the feature (Wu et al., 2018).
Revised: We follow the literature to construct the feature (Wu et al., 2018)

Original:  Speciﬁcally, we use the standard Morgan ﬁngerprint (Rogers & Hahn, 2010), 2,048 binary indicators of chemical substructures, for the classiﬁcation datasets, and ‘grid features’ (ﬁngerprints of pairs between ligand and protein, see Wu et al.
Revised: [Table] Speciﬁcally, we use the standard Morgan ﬁngerprint (Rogers & Hahn, 2010), 2,048 binary indicators of chemical substructures, for the classiﬁcation datasets [Table] and ‘grid features’ (ﬁngerprints of pairs between ligand and protein, see Wu et al.

Original: for the regression dataset.
Revised: for the regression dataset.

Original: Each dataset is splitted into (train, validation, test) sets under the criterion speciﬁed in MoleculeNet.
Revised: Each dataset is splitted into (train, validation, test) sets under the criterion speciﬁed in MoleculeNet.

Original: We compare L CN and its extensions (L LN , A LCN , and E LCN ) with the following baselines:
Revised: We compare L CN and its extensions (L LN , A LCN , and E LCN ) with the following baselines:

Original: • (Oblique) decision trees: C ART (Breiman et al.
Revised: • (Oblique) decision trees: C ART (Breiman et al.

Original: H HCART (Wickramarachchi et al.
Revised: H HCART (Wickramarachchi et al.

Original: (2016); oblique decision trees induced greedily on linear projections), and T AO (CarreiraPerpin´an & Tavallali (2018); oblique decision trees trained via alternating optimization).
Revised: (2016); oblique decision trees induced greedily on linear projections), and T AO (CarreiraPerpin´an & Tavallali (2018); oblique decision trees trained via alternating optimization).

Original: • Tree ensembles: R F (Breiman (2001); random forest) and G BDT (Friedman (2001); gradient boosting decision trees).
Revised: • Tree ensembles: R F (Breiman (2001); random forest) and G BDT (Friedman (2001); gradient boosting decision trees).

Original: • Graph networks: G CN (Duvenaud et al.
Revised: • Graph networks: G CN (Duvenaud et al.

Original: ; graph convolutional networks on molecules).
Revised: ; graph convolutional networks on molecules).

Original: For decision trees, L CN , L LN , and A LCN , we tune the tree depth in { 2 , 3 , . . .
Revised: For decision trees, L CN , L LN , and A LCN , we tune the tree depth in { 2 , 3 , . . .

Original: For L CN , L LN , and A LCN , we also tune the DropConnect probability in { 0 , 0 . 25 , 0 . 5 , 0 . 75 } .
Revised: For L CN , L LN , and A LCN , we also tune the DropConnect probability in { 0 , 0 . 25 , 0 . 5 , 0 . 75 } .

Original: Since regression tasks require precise estimations of the prediction values while classiﬁcation tasks do not, we tune the number of hidden layers of g φ in { 0 , 1 , 2 , 3 , 4 } (each with 256 neurons) for the regression task, and simply use a linear model g φ for the classiﬁcation tasks.
Revised: Since regression tasks require precise estimations of the prediction values while classiﬁcation tasks do not, we tune the number of hidden layers of g φ in { 0 , 1 , 2 , 3 , 4 } (each with 256 neurons) for the regression task, and simply use a linear model g φ for the classiﬁcation tasks.

Original: For E LCN , we use A LCN as the base model, tune the ensemble size E ∈ { 2 0 , 2 1 , . . .
Revised: For E LCN , we use A LCN as the base model, tune the ensemble size E ∈ { 2 0 , 2 1 , . . .

Original: , 2 6 } for the classiﬁcation tasks, and E ∈ { 2 0 , 2 1 , . .
Revised: , 2 6 } for the classiﬁcation tasks, and E ∈ { 2 0 , 2 1 , . .

Original: , 2 9 } for the regression task.
Revised: , 2 9 } for the regression task.

Original: To train our models, we use the cross entropy loss for the classiﬁcation tasks, and mean squared error for the regression task.
Revised: To train our models, we use the cross entropy loss for the classiﬁcation tasks, and mean squared error for the regression task.

Original: Other minor details are available in Appendix B.
Revised: Other minor details are available in Appendix B.

Original: We follow the chemistry literature (Wu et al., 2018) to measure the performance by AUC for classiﬁcation, and root-mean-squared error (RMSE) for regression.
Revised: We follow the chemistry literature (Wu et al., 2018) to measure the performance by AUC for classiﬁcation, and root-mean-squared error (RMSE) for regression.

Original: For each dataset, we train a model for  each label, compute the mean and standard deviation of the performance across 10 different random seeds, and report their average across all the labels within the dataset.
Revised: For each dataset, we train a model for [Figure] each label, compute the mean and standard deviation of the performance across 10 different random seeds, and report their average across all the labels within the dataset.

Original: The results are in Table 2.
Revised: The results are in Table 2.

Original: [Figure]

Original: Among the (oblique) decision tree training algorithms, our L CN achieves the state-of-the-art performance.
Revised: Among the (oblique) decision tree training algorithms, our L CN achieves the state-of-the-art performance.

Original: The continuous extension (A LCN ) always improves the empirical performance of L CN , which is expected since L CN is limited for the number of possible outputs (leaf nodes).
Revised: The continuous extension (A LCN ) always improves the empirical performance of L CN , which is expected since L CN is limited for the number of possible outputs (leaf nodes).

Original: Among the ensemble methods, the proposed E LCN always outperforms the classic counterpart, G BDT , and sometimes outperforms R F .
Revised: Among the ensemble methods, the proposed E LCN always outperforms the classic counterpart, G BDT , and sometimes outperforms R F .

Original: Overall, L CN is the state-of-the-art method for learning oblique decision trees, and E LCN performs competitively against other alternatives for training tree ensembles.
Revised: Overall, L CN is the state-of-the-art method for learning oblique decision trees, and E LCN performs competitively against other alternatives for training tree ensembles.

Original: Empirical analysis.
Revised: Empirical analysis.

Original: Here we analyze the proposed L CN in terms of the optimization and generalization performance in the large HIV dataset.
Revised: Here we analyze the proposed L CN in terms of the optimization and generalization performance in the large HIV dataset.

Original: We conduct an ablation study on the proposed method for training L CN in Figure 2a.
Revised: We conduct an ablation study on the proposed method for training L CN in Figure 2a.

Original: Direct training (without annealing) does not sufﬁce to learn L CN , while the proposed annealing succeed in optimization; even better optimization and generalization performance can be achieved by introducing DropConnect, which corroborates our hypothesis on the exploration effect during training in § 3.7 and its well-known regularization effect.
Revised: Direct training (without annealing) does not sufﬁce to learn L CN , while the proposed annealing succeed in optimization; even better optimization and generalization performance can be achieved by introducing DropConnect, which corroborates our hypothesis on the exploration effect during training in § 3.7 and its well-known regularization effect.

Original: Compared to other methods (Fig. 2b), only T AO has a comparable training performance.
Revised: Compared to other methods (Fig. 2b), only T AO has a comparable training performance.

Original: In terms of generalization (Fig. 2c), all of the competitors do not perform well and overﬁt fairly quickly.
Revised: In terms of generalization (Fig. 2c), all of the competitors do not perform well and overﬁt fairly quickly.

Original: In stark contrast,
Revised: In stark contrast,

Original: L CN outperforms the competitors by a large margin and gets even more accurate as the depth increases.
Revised: L CN outperforms the competitors by a large margin and gets even more accurate as the depth increases.

Original: This is expected due to the strong regularization of L CN that uses a linear number of effective weights to construct an exponential number of decision nodes, as discussed in § 3.5.
Revised: This is expected due to the strong regularization of L CN that uses a linear number of effective weights to construct an exponential number of decision nodes, as discussed in § 3.5.

Original: Some additional analysis and the visualization of the tree converted from L CN are included in Appendix C.
Revised: Some additional analysis and the visualization of the tree converted from L CN are included in Appendix C.

Original:  D ISCUSSION AND CONCLUSION
Revised:  D ISCUSSION AND CONCLUSION

Original: We create a novel neural architecture by casting the derivatives of deep networks as the representation, which realizes a new class of neural models that is equivalent to oblique decision trees.
Revised: We create a novel neural architecture by casting the derivatives of deep networks as the representation, which realizes a new class of neural models that is equivalent to oblique decision trees.

Original: The induced oblique decision trees embed rich structures and are compatible with deep learning methods.
Revised: The induced oblique decision trees embed rich structures and are compatible with deep learning methods.

Original: This work can be used to interpret methods that utilize derivatives of a network, such as training a generator through the gradient of a discriminator (Goodfellow et al., 2014).
Revised: This work can be used to interpret methods that utilize derivatives of a network, such as training a generator through the gradient of a discriminator (Goodfellow et al., 2014).

Original: The work opens up many avenues for future work, from building representations from the derivatives of neural models to the incorporation of more structures, such as the inner randomization of random forest.
Revised: The work opens up many avenues for future work, from building representations from the derivatives of neural models to the incorporation of more structures, such as the inner randomization of random forest.

Original: A CKNOWLEDGMENTS
Revised: A CKNOWLEDGMENTS

Original: GH and TJ were in part supported by a grant from Siemens Corporation.
Revised: GH and TJ were in part supported by a grant from Siemens Corporation.

Original: The authors thank Shubhendu Trivedi and Menghua Wu for proofreading, and thank the anonymous reviewers for their helpful comments.
Revised: The authors thank Shubhendu Trivedi and Menghua Wu for proofreading, and thank the anonymous reviewers for their helpful comments.

Original: A P ROOFS A. P ROOF OF L EMMA
Revised: A P ROOFS A. P ROOF OF L EMMA

Original: Proof.
Revised: Proof.

Original: We ﬁx j and do induction on i .
Revised: We ﬁx j and do induction on i .

Original: Without loss of generality, we assume 1 = r j (cid:54) =
Revised: Without loss of generality, we assume 1 = r j (cid:54) =

Original: r (cid:48)
Revised: r (cid:48)

Original: j = 0 .
Revised: j = 0 .

Original: If i = j , since r (cid:48)
Revised: If i = j , since r (cid:48)

Original: j = 0 , we have
Revised: j = 0 , we have

Original: [Equation]
Revised: [Equation]

Original: Hence, we have ω r
Revised: Hence, we have ω r

Original: [Equation]
Revised: [Equation]

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: We assume the statement holds for up to some integer i ≥ j :
Revised: We assume the statement holds for up to some integer i ≥ j :

Original: [Equation]
Revised: [Equation]

Original: for some α ∈ R .
Revised: for some α ∈ R .

Original: For i + 1 , we have
Revised: For i + 1 , we have

Original: [Equation]
Revised: [Equation]

Original: 1: k −
Revised: 1: k −

Original: [Equation]
Revised: [Equation]

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: 21 ,D +
Revised: 21 ,D +

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: +
Revised: +

Original: [Equation]
Revised: [Equation]

Original: k
Revised: k

Original: [Equation]
Revised: [Equation]

Original: W i
Revised: W i

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: × r (cid:48) k
Revised: × r (cid:48) k

Original: × ( ω r (cid:48) 1: k − 1 + α k × ω r 1: j − 1 ) , for some α k ∈ R =
Revised: × ( ω r (cid:48) 1: k − 1 + α k × ω r 1: j − 1 ) , for some α k ∈ R =

Original: [Equation]
Revised: [Equation]

Original: i +21 ,
Revised: i +21 ,

Original: [Equation]
Revised: [Equation]

Original: i +1 (cid:88) k
Revised: i +1 (cid:88) k

Original: [Equation]
Revised: [Equation]

Original: W i
Revised: W i

Original: [Equation]
Revised: [Equation]

Original: 1 ,D
Revised: 1 ,D

Original: [Equation]
Revised: [Equation]

Original: (cid:48)
Revised: (cid:48)

Original: [Equation]
Revised: [Equation]

Original: (cid:48) 1:
Revised: (cid:48) 1:

Original: [Equation]
Revised: [Equation]

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: (cid:88)
Revised: (cid:88)

Original: [Equation]
Revised: [Equation]

Original: , for some α ∈ R
Revised: , for some α ∈ R

Original: The proof follows by induction.
Revised: The proof follows by induction.

Original: A. P ROOF OF T HEOREM
Revised: A. P ROOF OF T HEOREM

Original: Proof.
Revised: Proof.

Original: We ﬁrst prove that we can represent any g φ ( (cid:126)J x ˜ a M ) as g (˜ o M ) .
Revised: We ﬁrst prove that we can represent any g φ ( (cid:126)J x ˜ a M ) as g (˜ o M ) .

Original: Note that for any x mapping to the same activation pattern ˜
Revised: Note that for any x mapping to the same activation pattern ˜

Original: o M , the Jacobian (cid:126)J x ˜ a M is constant.
Revised: o M , the Jacobian (cid:126)J x ˜ a M is constant.

Original: Hence, we may re-write the standard architecture g φ ( (cid:126)J x ˜ a M ) as g φ ( (cid:126)J (˜ o M )) , where (cid:126)J (˜ o M ) is the Jacobian corresponding to the activation pattern ˜ o
Revised: Hence, we may re-write the standard architecture g φ ( (cid:126)J x ˜ a M ) as g φ ( (cid:126)J (˜ o M )) , where (cid:126)J (˜ o M ) is the Jacobian corresponding to the activation pattern ˜ o

Original: M .
Revised: M .

Original: Then we can set g ( · ) (cid:44) g
Revised: Then we can set g ( · ) (cid:44) g

Original: φ ( (cid:126)J ( · )) , which concludes the ﬁrst part of the proof.
Revised: φ ( (cid:126)J ( · )) , which concludes the ﬁrst part of the proof.

Original: To prove the other direction, we ﬁrst prove that we can also write the activation pattern as a function of the Jacobian.
Revised: To prove the other direction, we ﬁrst prove that we can also write the activation pattern as a function of the Jacobian.

Original: We prove this by layer-wise induction (note that ˜ o M =
Revised: We prove this by layer-wise induction (note that ˜ o M =

Original: [ o 1 1 , . .
Revised: [ o 1 1 , . .

Original: , o M 1 ] and (cid:126)J x ˜ a M =
Revised: , o M 1 ] and (cid:126)J x ˜ a M =

Original: [ ∇ x a 11 , . . . , ∇ x a M 1 ] ):
Revised: [ ∇ x a 11 , . . . , ∇ x a M 1 ] ):

Original: The induction hypothesis ( i ≥ 2 ) is that
Revised: The induction hypothesis ( i ≥ 2 ) is that

Original: [ o 11 , . . .
Revised: [ o 11 , . . .

Original: , o i − 1 1 ] is a function of [ ∇ x a 11 , . .
Revised: , o i − 1 1 ] is a function of [ ∇ x a 11 , . .

Original: , ∇ x a i − 1 1 ] .
Revised: , ∇ x a i − 1 1 ] .

Original: If W 1 = 0 (zero vector), z 11 , a 11 , and o 11 are constant (thus being a function of ∇ x a 11 ).
Revised: If W 1 = 0 (zero vector), z 11 , a 11 , and o 11 are constant (thus being a function of ∇ x a 11 ).

Original: Otherwise, ∇ x a 11 = 0 ⇔ o 11 = 0 and ∇ x a 11 = W 1 ⇔ o 11 = 1 , so o 11 can be written as a function of ∇ x a 11 .
Revised: Otherwise, ∇ x a 11 = 0 ⇔ o 11 = 0 and ∇ x a 11 = W 1 ⇔ o 11 = 1 , so o 11 can be written as a function of ∇ x a 11 .

Original: If either o i 1 = 

Revised: If either o i 1 =

Original: or o i 1 = 1 is infeasible (but not both), by induction hypothesis, [ o 11 , . . .
Revised: or o i 1 = 1 is infeasible (but not both), by induction hypothesis, [ o 11 , . . .

Original: , o i 1 ] can be written as a function of [ ∇ x a 11 , . .
Revised: , o i 1 ] can be written as a function of [ ∇ x a 11 , . .

Original: ∇ x a i 1 ] .
Revised: ∇ x a i 1 ] .

Original: If o i 1 = 1 for some x (cid:48)
Revised: If o i 1 = 1 for some x (cid:48)

Original: and o i 1 = 0 for some x (cid:48)(cid:48) , we claim that o i 1 = 1 ⇒ ∇ x a i 1 (cid:54) = 0 :
Revised: and o i 1 = 0 for some x (cid:48)(cid:48) , we claim that o i 1 = 1 ⇒ ∇ x a i 1 (cid:54) = 0 :

Original: If o i 1 = 1 and ∇ x
Revised: If o i 1 = 1 and ∇ x

Original: a i 1 = 0 , we have o i 1 = 1 ⇒ a i 

Revised: a i 1 = 0 , we have o i 1 = 1 ⇒ a i

Original: =
Revised: =

Original: z i 1 ≥ 0 and 0 = ∇ x a i 1 = ∇ x
Revised: z i 1 ≥ 0 and 0 = ∇ x a i 1 = ∇ x

Original: z i 1 , which implies that the bias (of z i , given [ o 11 , . . .
Revised: z i 1 , which implies that the bias (of z i , given [ o 11 , . . .

Original: , o i − 1 1 ] )
Revised: , o i − 1 1 ] )

Original: z
Revised: z

Original: i 1 − ( ∇ x z i 1 ) (cid:62) x ≥ 0 .
Revised: i 1 − ( ∇ x z i 1 ) (cid:62) x ≥ 0 .

Original: Note that both ∇ x z i 1 and z i 1 − ( ∇ x z i 1 ) (cid:62) x are constant given [ o 11 , . . .
Revised: Note that both ∇ x z i 1 and z i 1 − ( ∇ x z i 1 ) (cid:62) x are constant given [ o 11 , . . .

Original: , o i − 1 1 ] , regardless of o i 1 .
Revised: , o i − 1 1 ] , regardless of o i 1 .

Original: Hence, given [ o 11 , . . .
Revised: Hence, given [ o 11 , . . .

Original: , o i − 1 1 ] , we have z i 

Revised: , o i − 1 1 ] , we have z i

Original: =
Revised: =

Original: z i 1 − ( ∇ x z i 1 ) (cid:62) x ≥ 

Revised: z i 1 − ( ∇ x z i 1 ) (cid:62) x ≥

Original: and o i 1 = 0 is infeasible ( ⇒⇐ ).
Revised: and o i 1 = 0 is infeasible ( ⇒⇐ ).

Original: Note that, given ﬁxed [ o 11 , . . .
Revised: Note that, given ﬁxed [ o 11 , . . .

Original: , o i − 1 1 ] , ∇ x a i 1 (cid:54) = 0 has a unique value in R d .
Revised: , o i − 1 1 ] , ∇ x a i 1 (cid:54) = 0 has a unique value in R d .

Original: Combining the result o i 1 = 1 ⇒ ∇ x a i 1 (cid:54)
Revised: Combining the result o i 1 = 1 ⇒ ∇ x a i 1 (cid:54)

Original: = 

Revised: =

Original: with o i 1 = 

Revised: with o i 1 =

Original: ⇒ ∇ x a i 1 = 0 , there is a bijection between o i 1 and ∇ x a i 1 in this case, which implies that [ o 11 , . . .
Revised: ⇒ ∇ x a i 1 = 0 , there is a bijection between o i 1 and ∇ x a i 1 in this case, which implies that [ o 11 , . . .

Original: , o i 1 ] can be written as a function of [ ∇ x a 11 , . .
Revised: , o i 1 ] can be written as a function of [ ∇ x a 11 , . .

Original: ∇ x a i 1 ] .
Revised: ∇ x a i 1 ] .

Original: The derivation implies that we may re-write the canonical architecture g (˜ o M ) as g (˜ o
Revised: The derivation implies that we may re-write the canonical architecture g (˜ o M ) as g (˜ o

Original: (cid:126)J x ˜ a M )) ,
Revised: (cid:126)J x ˜ a M )) ,

Original: where ˜ o
Revised: where ˜ o

Original: ( (cid:126) J x ˜ a M ) is the activation pattern corresponding to the Jacobian (cid:126)
Revised: ( (cid:126) J x ˜ a M ) is the activation pattern corresponding to the Jacobian (cid:126)

Original: J x ˜ a M .
Revised: J x ˜ a M .

Original: Hence, it sufﬁces to establish that there exists a feed-forward network g φ such that g φ ( (cid:126)J x ˜ a M ) =
Revised: Hence, it sufﬁces to establish that there exists a feed-forward network g φ such that g φ ( (cid:126)J x ˜ a M ) =

Original: g (˜ o ( (cid:126)J x ˜ a M )) for at most 2 M distinct (cid:126)J x ˜ a M , which can be found by the Theorem 2.5 of Hornik et al.
Revised: g (˜ o ( (cid:126)J x ˜ a M )) for at most 2 M distinct (cid:126)J x ˜ a M , which can be found by the Theorem 2.5 of Hornik et al.

Original: (1989) or the
Revised: (1989) or the

Original: Theorem 1 of Zhang et al.
Revised: Theorem 1 of Zhang et al.

Original: B I MPLEMENTATION DETAILS
Revised: B I MPLEMENTATION DETAILS

Original: Here we provide the full version of the implementation details.
Revised: Here we provide the full version of the implementation details.

Original: For the baseline methods:
Revised: For the baseline methods:

Original: • C ART , H HCART , and T AO : we tune the tree depth in { 2 , 3 , . . .
Revised: • C ART , H HCART , and T AO : we tune the tree depth in { 2 , 3 , . . .

Original: • R F : we use the scikit-learn (Pedregosa et al., 2011) implementation of random forest.
Revised: • R F : we use the scikit-learn (Pedregosa et al., 2011) implementation of random forest.

Original: We set the number of estimators as 500 .
Revised: We set the number of estimators as 500 .

Original: • G BDT : we use the scikit-learn (Pedregosa et al., 2011) implementation of gradient boosting trees.
Revised: • G BDT : we use the scikit-learn (Pedregosa et al., 2011) implementation of gradient boosting trees.

Original: We tune the number of estimators in { 2 3 , 2 4 , . . .
Revised: We tune the number of estimators in { 2 3 , 2 4 , . . .

Original: For L CN , L LN , and A LCN , we run the same training procedure.
Revised: For L CN , L LN , and A LCN , we run the same training procedure.

Original: For all the datasets, we tune the depth in { 2 , 3 , . . .
Revised: For all the datasets, we tune the depth in { 2 , 3 , . . .

Original: , 12 } and the DropConnect probability in { 0 , 0 . 25 , 0 . 5 , 0 . 75 } .
Revised: , 12 } and the DropConnect probability in { 0 , 0 . 25 , 0 . 5 , 0 . 75 } .

Original: The models are optimized with mini-batch stochastic gradient descent with batch size set to 64 .
Revised: The models are optimized with mini-batch stochastic gradient descent with batch size set to 64 .

Original: For all the classiﬁcation tasks, we set the learning rate as 0 . 1 , which is annealed by a factor of 10 for every 10 epochs ( 30 epochs in total).
Revised: For all the classiﬁcation tasks, we set the learning rate as 0 . 1 , which is annealed by a factor of 10 for every 10 epochs ( 30 epochs in total).

Original: For the regression task, we set the learning rate as 0 . 0001 , which is annealed by a factor of 10 for every 30 epochs ( 60 epochs in total).
Revised: For the regression task, we set the learning rate as 0 . 0001 , which is annealed by a factor of 10 for every 30 epochs ( 60 epochs in total).

Original: Both L CN and A LCN have an extra fully-connected network g φ , which transforms the derivatives (cid:126)J x ˜ a M to the ﬁnal outputs.
Revised: Both L CN and A LCN have an extra fully-connected network g φ , which transforms the derivatives (cid:126)J x ˜ a M to the ﬁnal outputs.

Original: Since regression tasks require precise estimation of prediction values while classiﬁcation tasks do not, we tune the number of hidden layers of g φ in { 0 , 1 , 2 , 3 , 4 } (each with 256 neurons) for the regression dataset, and simply use a linear g φ for the classiﬁcation datasets.
Revised: Since regression tasks require precise estimation of prediction values while classiﬁcation tasks do not, we tune the number of hidden layers of g φ in { 0 , 1 , 2 , 3 , 4 } (each with 256 neurons) for the regression dataset, and simply use a linear g φ for the classiﬁcation datasets.

Original: For E LCN , we ﬁx the depth to 12 and tune the number of base models E ∈ { 2 0 , 2 1 , . . .
Revised: For E LCN , we ﬁx the depth to 12 and tune the number of base models E ∈ { 2 0 , 2 1 , . . .

Original: , 2 6 } for the classiﬁcation tasks, and E ∈ { 2 0 , 2 1 , . .
Revised: , 2 6 } for the classiﬁcation tasks, and E ∈ { 2 0 , 2 1 , . .

Original: , 2 9 } for the regression task.
Revised: , 2 9 } for the regression task.

Original: We set the DropConnect probability as 0 .
Revised: We set the DropConnect probability as 0 .

Original: 75 to encourage strong regularization for the classiﬁcation tasks, and as 0 .
Revised: 75 to encourage strong regularization for the classiﬁcation tasks, and as 0 .

Original: 25 to impose mild regularization for the regression task (because regression is hard to ﬁt).
Revised: 25 to impose mild regularization for the regression task (because regression is hard to ﬁt).

Original: We found stochastic gradient descent does not sufﬁce to incrementally learn the E LCN , so we use the AMSGrad optimizer (Reddi et al., 2018) instead.
Revised: We found stochastic gradient descent does not sufﬁce to incrementally learn the E LCN , so we use the AMSGrad optimizer (Reddi et al., 2018) instead.

Original: We set the batch size as 256 and train each partial ensemble for 30 epochs.
Revised: We set the batch size as 256 and train each partial ensemble for 30 epochs.

Original: The learning rate is 0 .
Revised: The learning rate is 0 .

Original: 01 for the classiﬁcation tasks, and 0 .
Revised: 01 for the classiﬁcation tasks, and 0 .

Original: for the regression task.
Revised: for the regression task.

Original: To train our models, we use the cross entropy loss for the classiﬁcation tasks, and mean squared error for the regression task.
Revised: To train our models, we use the cross entropy loss for the classiﬁcation tasks, and mean squared error for the regression task.

Original: [Table]
Revised: [Table]

Original: C S UPPLEMENTARY EMPIRICAL ANALYSIS AND VISUALIZATION C. S UPPLEMENTARY EMPIRICAL ANALYSIS
Revised: C S UPPLEMENTARY EMPIRICAL ANALYSIS AND VISUALIZATION C. S UPPLEMENTARY EMPIRICAL ANALYSIS

Original: In this section
Revised: In this section

Original: [Table]
Revised: [Table]

Original: we investigate the learning of “unobserved branching / leaves” discussed in § 3.6.
Revised: we investigate the learning of “unobserved branching / leaves” discussed in § 3.6.

Original: The “unobserved branching / leaves” refer to the decision and leaf nodes of the oblique decision tree converted from L CN , such that there is no training data that are routed to the nodes.
Revised: The “unobserved branching / leaves” refer to the decision and leaf nodes of the oblique decision tree converted from L CN , such that there is no training data that are routed to the nodes.

Original: It is impossible for traditional (oblique) decision tree training algorithms to learn the values of such nodes (e
Revised: It is impossible for traditional (oblique) decision tree training algorithms to learn the values of such nodes (e

Original: [Table]
Revised: [Table]

Original: g., the output value of a leaf node in the traditional framework is based on the training data that are routed to the leaf node).
Revised: g., the output value of a leaf node in the traditional framework is based on the training data that are routed to the leaf node).

Original: However, the shared parameterization in our oblique decision tree provides a means to update such unobserved nodes during training (see the discussion in § 3.6)
Revised: However, the shared parameterization in our oblique decision tree provides a means to update such unobserved nodes during training (see the discussion in § 3.6)

Original: [Table]
Revised: [Table]

Original: Since the above scenario in general happens more frequently in small datasets than in large datasets
Revised: Since the above scenario in general happens more frequently in small datasets than in large datasets

Original: [Table]
Revised: [Table]

Original: we evaluate the scenario on the small Bace dataset (binary classiﬁcation task).
Revised: we evaluate the scenario on the small Bace dataset (binary classiﬁcation task).

Original: Here we empirically analyze a few things pertaining to the unobserved nodes:
Revised: Here we empirically analyze a few things pertaining to the unobserved nodes:

Original: • # of training patterns: the number of distinct end-to-end activation / decision patterns r 1: M encountered in the training data.
Revised: • # of training patterns: the number of distinct end-to-end activation / decision patterns r 1: M encountered in the training data.

Original: • # of testing patterns: the number of distinct end-to-end activation / decision patterns r 1: M encountered ib the testing data.
Revised: • # of testing patterns: the number of distinct end-to-end activation / decision patterns r 1: M encountered ib the testing data.

Original: • # of testing patterns - training patterns: the number of distinct end-to-end activation / decision patterns r 1: M that is only encountered in the testing data but not in the training data.
Revised: • # of testing patterns - training patterns: the number of distinct end-to-end activation / decision patterns r 1: M that is only encountered in the testing data but not in the training data.

Original: • Ratio of testing points w/ unobserved patterns: the number of testing points that yield unobserved patterns divided by the total number of testing points.
Revised: • Ratio of testing points w/ unobserved patterns: the number of testing points that yield unobserved patterns divided by the total number of testing points.

Original: • Testing performance - observed patterns: here we denote the number of testing data as n , the prediction and label of the
Revised: • Testing performance - observed patterns: here we denote the number of testing data as n , the prediction and label of the

Original: i th as ˆ y i ∈ [0 , 1] and y i ∈ { 0 , 1 } , respectively.
Revised: i th as ˆ y i ∈ [0 , 1] and y i ∈ { 0 , 1 } , respectively.

Original: We collect the subset of indices I of the testing data such that their activation / decision patterns r 1: M are observed in the training data, and then compute the performance of their predictions.
Revised: We collect the subset of indices I of the testing data such that their activation / decision patterns r 1: M are observed in the training data, and then compute the performance of their predictions.

Original: Since the original performance is measured by AUC, here we generalize AUC to measure a subset of points I as:
Revised: Since the original performance is measured by AUC, here we generalize AUC to measure a subset of points I as:

Original: [Equation]
Revised: [Equation]

Original: When I = [ n ]
Revised: When I = [ n ]

Original: [Equation]
Revised: [Equation]

Original: the above measure recovers AUC.
Revised: the above measure recovers AUC.

Original: • Testing performance - unobserved patterns: the same as above, but use I for the testing data such that their activation / decision patterns r 1: M are unobserved in the training data.
Revised: • Testing performance - unobserved patterns: the same as above, but use I for the testing data such that their activation / decision patterns r 1: M are unobserved in the training data.

Original: The results are in Table 3.
Revised: The results are in Table 3.

Original: There are some interesting ﬁndings.
Revised: There are some interesting ﬁndings.

Original: For example, there is an exponential number of possible patterns, but the number of patterns that appear in the dataset is quite small.
Revised: For example, there is an exponential number of possible patterns, but the number of patterns that appear in the dataset is quite small.

Original: The ratio of testing points with unobserved patterns is also small, but these unobserved branching / leaves seem to be controlled properly.
Revised: The ratio of testing points with unobserved patterns is also small, but these unobserved branching / leaves seem to be controlled properly.

Original: They do not lead to completely different performance compared to those that are observed during training.
Revised: They do not lead to completely different performance compared to those that are observed during training.

Original: C. V ISUALIZATION
Revised: C. V ISUALIZATION

Original: Here we visualize the learned locally constant network on the HIV dataset in the representation of its equivalent oblique decision tree in Fig.
Revised: Here we visualize the learned locally constant network on the HIV dataset in the representation of its equivalent oblique decision tree in Fig.

Original: Since the dimension of Morgan ﬁngerprint (Rogers &
Revised: Since the dimension of Morgan ﬁngerprint (Rogers &

Original: Hahn, 2010) is quite high (2,048), here we only visualize the top-K weights (in terms of the absolute value) for each decision node.
Revised: Hahn, 2010) is quite high (2,048), here we only visualize the top-K weights (in terms of the absolute value) for each decision node.

Original: We also normalize each weight such that the (cid:96) 1 norm of each weight is 1 .
Revised: We also normalize each weight such that the (cid:96) 1 norm of each weight is 1 .

Original: Since the task is evaluated by ranking (AUC), we visualize the leaf nodes in terms of the ranking of output probability among the leaf nodes (the higher the more likely).
Revised: Since the task is evaluated by ranking (AUC), we visualize the leaf nodes in terms of the ranking of output probability among the leaf nodes (the higher the more likely).

Original: Note that a complete visualization requires some engineering efforts.
Revised: Note that a complete visualization requires some engineering efforts.

Original: Our main contribution here is the algorithm that transforms an L CN to an oblique decision tree, rather than the visualization of oblique decision trees, so we only provide the initial visualization as a proof of concept.
Revised: Our main contribution here is the algorithm that transforms an L CN to an oblique decision tree, rather than the visualization of oblique decision trees, so we only provide the initial visualization as a proof of concept.

Original: + … 0 .- 0 .
Revised: + … 0 .- 0 .

Original:           - 0 .+ 

Revised:           - 0 .+

Original: .+ … - 0 .- 0 .- 0 .- 
 .+ … - 0 .- 0 .- 0 .- 

Revised: .+ … - 0 .- 0 .- 0 .- 
 .+ … - 0 .- 0 .- 0 .-

Original: .+ … - 0 .- 0 .- 0 .- 
 .+ … - 0 .- 0 .- 0 .- 

Revised: .+ … - 0 .- 0 .- 0 .- 
 .+ … - 0 .- 0 .- 0 .-

Original: .+ … - 0 .+ 

Revised: .+ … - 0 .+

Original: .+ … - 0 .+ 

Revised: .+ … - 0 .+

Original: .+ … - 0 .- 0 .- 0 .- 
 .+ … - 0 .- 0 .- 0 .- 

Revised: .+ … - 0 .- 0 .- 0 .- 
 .+ … - 0 .- 0 .- 0 .-

Original: .+ … 0 .- 

Revised: .+ … 0 .-

Original: .+ … - 0 .+ 

Revised: .+ … - 0 .+

Original: .+ … - 0 . 

Revised: .+ … - 0 .

Original: .+ … 0 .- 
 .+ …  - 0 .+ 

Revised: .+ … 0 .- 
 .+ …  - 0 .+

Original: .+ …
Revised: .+ …

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: <
Revised: <

Original: [Table]
Revised: [Table]

Original: <
Revised: <

Original: [Table]
Revised: [Table]

Original: <
Revised: <

Original: [Table]
Revised: [Table]

Original: the leaves indicates the ranking of output probability among the 16 leaves (the exact value is not important).
Revised: the leaves indicates the ranking of output probability among the 16 leaves (the exact value is not important).

Original: See the descriptions in Appendix C.2.
Revised: See the descriptions in Appendix C.2.