Original: L EARNING CONCISE REPRESENTATIONS FOR REGRESSION BY EVOLVING NETWORKS OF TREES
Revised: L EARNING CONCISE REPRESENTATIONS FOR REGRESSION BY EVOLVING NETWORKS OF TREES

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: We propose and study a method for learning interpretable representations for the task of regression.
Revised: We propose and study a method for learning interpretable representations for the task of regression.

Original: Features are represented as networks of multi-type expression trees comprised of activation functions common in neural networks in addition to other elementary functions.
Revised: Features are represented as networks of multi-type expression trees comprised of activation functions common in neural networks in addition to other elementary functions.

Original: Differentiable features are trained via gradient descent, and the performance of features in a linear model is used to weight the rate of change among subcomponents of each representation.
Revised: Differentiable features are trained via gradient descent, and the performance of features in a linear model is used to weight the rate of change among subcomponents of each representation.

Original: The search process maintains an archive of representations with accuracy-complexity trade-offs to assist in generalization and interpretation.
Revised: The search process maintains an archive of representations with accuracy-complexity trade-offs to assist in generalization and interpretation.

Original: We compare several stochastic optimization approaches within this framework.
Revised: We compare several stochastic optimization approaches within this framework.

Original: We benchmark these variants on 100 open-source regression problems in comparison to state-of-the-art machine learning approaches.
Revised: We benchmark these variants on 100 open-source regression problems in comparison to state-of-the-art machine learning approaches.

Original: Our main ﬁnding is that this approach produces the highest average test scores across problems while producing representations that are orders of magnitude smaller than the next best performing method (gradient boosting).
Revised: Our main ﬁnding is that this approach produces the highest average test scores across problems while producing representations that are orders of magnitude smaller than the next best performing method (gradient boosting).

Original: We also report a negative result in which attempts to directly optimize the disentanglement of the representation results in more highly correlated features.
Revised: We also report a negative result in which attempts to directly optimize the disentanglement of the representation result in more highly correlated features.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: The performance of a machine learning (ML) model depends primarily on the data representation used in training (Bengio et al., 2013), and for this reason the representational capacity of neural networks (NN) is considered a central factor in their success in many applications (Goodfellow et al., 2016).
Revised: The performance of a machine learning (ML) model depends primarily on the data representation used in training (Bengio et al., 2013) and for this reason the representational capacity of neural networks (NN) is considered a central factor in their success in many applications (Goodfellow et al., 2016).

Original: To date, there does not seem to be a consensus on how the architecture should be designed.
Revised: To date, there does not seem to be a consensus on how the architecture should be designed.

Original: As problems grow in complexity, the networks proposed to solve these problems grow as well, leading to an intractable design space.
Revised: As problems grow in complexity, the networks proposed to tackle them grow as well, leading to an intractable design space.

Original: One design approach is to tune network architectures through network hyperparameters using grid search or randomized search (Bergstra & Bengio, 2012) with cross validation.
Revised: One design approach is to tune network architectures through network hyperparameters using grid search or randomized search (Bergstra & Bengio, 2012) with cross validation.

Original: Often some combination of hyperparameter tuning and manual design by expertise/intuition is done (Goodfellow et al., 2016).
Revised: Often some combination of hyperparameter tuning and manual design by expertise/intuition is done (Goodfellow et al., 2016).

Original: Many approaches to network architecture search exist, including weight sharing (Pham et al., 2018) and reinforcement learning (Zoph & Le, 2016).
Revised: Many approaches to network architecture search exist, including weight sharing (Pham et al., 2018) and reinforcement learning (Zoph & Le, 2016).

Original: Another potential solution explored in this work (and others) is to use population-based stochastic optimization (SO) methods, also known as metaheuristics (Luke, 2013).
Revised: Another potential solution explored in this work (and others) is to use population-based stochastic optimization (SO) methods, also known as metaheuristics (Luke, 2013).

Original: In SO, several candidate solutions are evaluated and varied over several iterations, and heuristics are used to select and update the candidate networks until the population produces a desirable architecture.
Revised: In SO, several candidate solutions are evaluated and varied over several iterations, and heuristics are used to select and update the candidate networks until the population produces a desirable architecture.

Original: The general approach has been studied at least since the late 80s in various forms (Miller et al., 1989; Yao, 1999; Stanley & Miikkulainen, 2002) for NN design, with several recent applications (Real et al., 2017; Jaderberg et al., 2017;Real, 2018; Conti et al., 2017).
Revised: The general approach has been studied at least since the late 80s in various forms (Miller et al., 1989; Yao, 1999; Stanley & Miikkulainen, 2002) for NN design, with several recent applications (Real et al., 2017; Jaderberg et al., 2017; Conti et al., 2017; Real, 2018).

Original: In practice, the adequacy of the architecture is often dependent on conﬂicting objectives.
Revised: In practice, the adequacy of the architecture is often dependent on conﬂicting objectives.

Original: For example, interpretability may be a central concern, because many researchers in the scientiﬁc community rely on ML models not only to provide predictions that match data from various processes, but to provide insight into the nature of the processes themselves.
Revised: For example, interpretability may be a central concern, because many researchers in the scientiﬁc community rely on ML models not only to provide predictions that match data from various processes, but to provide insight into the nature of the processes themselves.

Original: Approaches to interpretability can be roughly grouped into semantic and syntactic approaches.
Revised: Approaches to interpretability can be roughly grouped into semantic and syntactic approaches.

Original: Semantic approaches encompass methods that attempt to elucidate the behavior of a model under various input conditions as a way of explanation (e.g. (Ribeiro et al., 2016)).
Revised: Semantic approaches encompass methods that attempt to elucidate the behavior of a model under various input conditions as a way of explanation (e.g. (Ribeiro et al., 2016)).

Original: Syntactic methods instead focus on the development of concise models that offer insight by virtue of their simplicity, in a similar vein to models built from ﬁrst-principles (e.g. (Tibshirani, 1996; Schmidt & Lipson, 2009)).
Revised: Syntactic methods instead focus on the development of concise models that offer insight by virtue of their simplicity, in a similar vein to models built from ﬁrst-principles (e.g. (Tibshirani, 1996; Schmidt & Lipson, 2009)).

Original: Akin to the latter group, our goal is to discover the simplest description of a process whose predictions generalize as well as possible.
Revised: Akin to the latter group, our goal is to discover the simplest description of a process whose predictions generalize as well as possible.

Original: Good representations should also disentangle the factors of variation (Bengio et al., 2013) in the data, in order to ease model interpretation.
Revised: Good representations should also disentangle the factors of variation (Bengio et al., 2013) in the data, in order to ease model interpretation.

Original: Disentanglement implies functional modularity; i.e., sub-components of the network should encapsulate behaviors that model a sub-process of the task.
Revised: Disentanglement implies functional modularity; i.e., sub-components of the network should encapsulate behaviors that model a sub-process of the task.

Original: In this sense, stochastic methods such as evolutionary computation (EC) appear well-motivated, as they are premised on the identiﬁcation and propagation of building blocks of solutions (Holland, 1975).
Revised: In this sense, stochastic methods such as evolutionary computation (EC) appear well-motivated, as they are premised on the identiﬁcation and propagation of building blocks of solutions (Holland, 1975).

Original: Experiments with EC applied to networks suggest it pressures networks to be modular (Huizinga et al., 2014; Kashtan & Alon, 2005).
Revised: Experiments with EC applied to networks suggest it pressures networks to be modular (Huizinga et al., 2014; Kashtan & Alon, 2005).

Original: Although the identiﬁcation functional building blocks of solutions sounds ideal, we have no way of knowing a priori whether a given problem will admit the identiﬁcation of building blocks of solutions via heuristic search (Oppacher, 2014).
Revised: Although the identiﬁcation functional building blocks of solutions sounds ideal, we have no way of knowing a priori whether a given problem will admit the identiﬁcation of building blocks of solutions via heuristic search (Oppacher, 2014).

Original: Our goal in this paper is thus to empirically assess the performance of several SO approaches in a system designed to produce intelligible representations from NN building blocks for regression.
Revised: Our goal in this paper is thus to empirically assess the performance of several SO approaches in a system designed to produce intelligible representations from NN building blocks for regression.

Original: In Section 2, we introduce a new method for optimizing representations that we call the feature engineering archiving tool (FEAT).
Revised: In Section 2, we introduce a new method for optimizing representations that we call the feature engineering automation tool (FEAT) 1 .

Original: The purpose of this method is to optimize an archive of representations that characterize the trade-off between conciseness and accuracy among representations.
Revised: The purpose of this method is to optimize an archive of representations that characterize the trade-off between conciseness and accuracy among representations.

Original: Algorithmically, two aspects of the method distinguish FEAT from previous work.
Revised: Algorithmically, two aspects of the method distinguish FEAT from previous work.

Original: First, it represents the internal structure of each NN as a set of syntax trees, with the goal of improving the transparency of the resultant representations.
Revised: First, it represents the internal structure of each NN as a set of syntax trees, with the goal of improving the transparency of the resultant representations.

Original: Second, it uses weights learned via gradient descent to provide feedback to the variation process at a more granular level.
Revised: Second, it uses weights learned via gradient descent to provide feedback to the variation process at a more granular level.

Original: We compare several multi-objective variants of this approach using EC and non-EC methods with different sets of objectives.
Revised: We compare several multi-objective variants of this approach using EC and non-EC methods with different sets of objectives.

Original: We discuss related work in more detail in Section 3.
Revised: We discuss related work in more detail in Section 3.

Original: In section 4 and 5, we describe and conduct an experiment that benchmarks FEAT against state-of-the-art ML methods on 100 open-source regression problems.
Revised: In section 4 and 5, we describe and conduct an experiment that benchmarks FEAT against state-of-the-art ML methods on 100 open-source regression problems.

Original: Future work based on this analysis is discussed in Section 6, and additional detailed results are provided in the Appendix.
Revised: Future work based on this analysis is discussed in Section 6, and additional detailed results are provided in the Appendix.

Original:  M ETHODS
Revised:  M ETHODS

Original: We are interested in the task of regression, for which the goal is to build a predictive model
Revised: We are interested in the task of regression, for which the goal is to build a predictive model

Original: ˆ y ( x ) using
Revised: ˆ y ( x ) using

Original: N paired examples T
Revised: N paired examples T

Original: = { ( x i , y i ) } Ni =1 .
Revised: = { ( x i , y i ) } Ni =1 .

Original: The regression model ˆ y ( x ) associates the inputs x ∈ R d with a real-valued output y ∈ R .
Revised: The regression model ˆ y ( x ) associates the inputs x ∈ R d with a real-valued output y ∈ R .

Original: The goal of feature engineering / representation learning is to ﬁnd a new representation of x via a m -dimensional feature mapping φ ( x ) :
Revised: The goal of feature engineering / representation learning is to ﬁnd a new representation of x via a m -dimensional feature mapping φ ( x ) :

Original: R d → R m , such that a model ˆ y ( φ ( x )) outperforms the model ˆ y ( x ) .
Revised: R d → R m , such that a model ˆ y ( φ ( x )) outperforms the model ˆ y ( x ) .

Original: We will assume that each predictor in x is scaled to zero mean, unit-variance.
Revised: We will assume that each predictor in x is scaled to zero mean, unit-variance.

Original: When applying a NN to a traditional ML task like regression or classiﬁcation, a ﬁxed NN architecture φ ( x , θ ) , parameterized by θ , is chosen and used to ﬁt a model
Revised: When applying a NN to a traditional ML task like regression or classiﬁcation, a ﬁxed NN architecture φ ( x , θ ) , parameterized by θ , is chosen and used to ﬁt a model

Original: [Equation]
Revised: [Equation]

Original: In this case φ =
Revised: In this case φ =

Original: [ φ 1 . . .
Revised: [ φ 1 . . .

Original: φ m ] T is a NN representation with m nodes in the ﬁnal hidden layer and a linear output layer with estimated coefﬁcients ˆ β =
Revised: φ m ] T is a NN representation with m nodes in the ﬁnal hidden layer and a linear output layer with estimated coefﬁcients ˆ β =

Original: [ˆ β 1 . . .
Revised: [ˆ β 1 . . .

Original: ˆ β m ] T .
Revised: ˆ β m ] T .

Original: Typically the problem is then cast as a parameter optimization problem that minimizes a loss function via gradient descent.
Revised: Typically the problem is then cast as a parameter optimization problem that minimizes a loss function via gradient descent.

Original: In order to tune the structure of the representation, we instead wish to solve the joint optimization problem
Revised: In order to tune the structure of the representation, we instead wish to solve the joint optimization problem

Original: [Equation]
Revised: [Equation]

Original: where ˆ φ ( x , ˆ θ ) is chosen to minimize a cost function L , with global optimum φ ∗ ( x , θ ∗ ) .
Revised: where ˆ φ ( x , ˆ θ ) is chosen to minimize a cost function L , with global optimum φ ∗ ( x , θ ∗ ) .

Original: ( L may depend on θ and β in the case of regularization.)
Revised: ( L may depend on θ and β in the case of regularization.)

Original: S is the space of possible representations realizable by the search procedure, and φ ∗ is the true structure of the process underlying the data.
Revised: S is the space of possible representations realizable by the search procedure, and φ ∗ is the true structure of the process underlying the data.

Original: The assumption of SO approaches such as evolutionary computation (EC) and simulated annealing (SA) is that candidate solutions in S that are similar to each other, i.e. reachable in few mutations, are more likely to have similar costs than candidate solutions that are far apart.
Revised: The assumption of SO approaches such as evolutionary computation (EC) [Table] is that candidate solutions in S that are similar to each other, i.e. reachable in few mutations, are more likely to have similar costs than candidate solutions that are far apart.

Original: In these cases, despite
Revised: In these cases, despite

Original: Eqn.
Revised: Eqn.

Original: 2 being non-convex, S can be effectively searched by maintaining and updating a population of candidate representations that perform well.
Revised: 2 being non-convex, S can be effectively searched by maintaining and updating a population of candidate representations that perform well.

Original: Multi-objective SO methods extend Eqn. 2 to minimizing additional cost functions (Deb et al., 2000).[Table] { x }
Revised: Multi-objective SO methods extend Eqn. 2 to minimizing additional cost functions (Deb et al., 2000).

Original: 2. FEAT
Revised: 2. FEAT

Original: FEAT uses a typical µ + λ evolutionary updating scheme, where µ = λ = P .
Revised: FEAT uses a typical µ + λ evolutionary updating scheme, where µ = λ = P .

Original: The method optimizes a population of potential representations, N = { n 1 . . .
Revised: The method optimizes a population of potential representations, N = { n 1 . . .

Original: n P } , where n is an “individual" in the population, iterating through these steps:
Revised: n P } , where n is an “individual" in the population, iterating through these steps:

Original: Fit a linear model ˆ y = x
Revised: Fit a linear model ˆ y = x

Original: T ˆ β .
Revised: T ˆ β .

Original: Create an initial population N consisting of this initial representation, φ = x , along with P − 1 randomly generated representations that sample x proportionally to ˆ β . 2.
Revised: Create an initial population N consisting of this initial representation, φ = x , along with P − 1 randomly generated representations that sample x proportionally to ˆ β . 2.

Original: While the stop criterion is not met: (a) Select parents P ⊆
Revised: While the stop criterion is not met: (a) Select parents P ⊆

Original: N using a selection algorithm.
Revised: N using a selection algorithm.

Original: (b) Apply variation operators to parents to generate P offspring O ; N = N ∪ O
Revised: (b) Apply variation operators to parents to generate P offspring O ; N = N ∪ O

Original: (c) Reduce N to P individuals using a survival algorithm.
Revised: (c) Reduce N to P individuals using a survival algorithm.

Original: Select and return n ∈ N with the lowest error on a hold-out validation set.
Revised: Select and return n ∈ N with the lowest error on a hold-out validation set.

Original: Individuals are evaluated using an initial forward pass, after which each representation is used to ﬁt a linear model (Eqn. 1) using ridge regression (Hoerl & Kennard, 1970).
Revised: Individuals are evaluated using an initial forward pass, after which each representation is used to ﬁt a linear model (Eqn. 1) using ridge regression (Hoerl & Kennard, 1970).

Original: The weights of the differentiable features in the representation are then updated using stochastic gradient descent.
Revised: The weights of the differentiable features in the representation are then updated using stochastic gradient descent.

Original: 2.1. R EPRESENTATION
Revised: 2.1. R EPRESENTATION

Original: The salient aspect of the proposed method is its use of syntax trees to represent the internal architecture of the network, as shown in Fig.
Revised: The salient aspect of the proposed method is its use of syntax trees to represent the internal architecture of the network, as shown in Fig.

Original: FEAT constructs these trees from elementary boolean- and continuousvalued functions and literals (see Table 1).
Revised: FEAT constructs these trees from elementary boolean- and continuousvalued functions and literals (see Table 1).

Original: This scheme is inspired by symbolic regression (SR) (Koza, 1992).
Revised: This scheme is inspired by symbolic regression (SR) (Koza, 1992).

Original: In contrast to typical SR, each individual n is a set of such trees, the output of which is interpreted as a candidate representation, i.e. φ ( x ) =
Revised: In contrast to typical SR, each individual n is a set of such trees, the output of which is interpreted as a candidate representation, i.e. φ ( x ) =

Original: [ φ 1 . . .
Revised: [ φ 1 . . .

Original: φ m ] for an individual with m trees.
Revised: φ m ] for an individual with m trees.

Original: The second difference from traditional SR is that the weights of differentiable nodes are encoded in the edges of the graph, rather than as independent nodes.
Revised: The second difference from traditional SR is that the weights of differentiable nodes are encoded in the edges of the graph, rather than as independent nodes.

Original: We include instructions typically used as activation functions used in NN, e.g. tanh, sigmoid, logit and relu nodes, elementary arithmetic and boolean operators.
Revised: We include instructions typically used as activation functions used in NN, e.g. tanh, sigmoid, logit and relu nodes, elementary arithmetic and boolean operators.

Original: Although a fully connected feedforward
Revised: Although a fully connected feedforward

Original: NN could be represented by this construction, representations in FEAT are biased to be thinly connected.
Revised: NN could be represented by this construction, representations in FEAT are biased to be thinly connected.

Original: Our hypothesis is that by doing so, we will improve the representation’s legibility without sacriﬁcing its capacity for modelling nonlinear relationships.
Revised: Our hypothesis is that by doing so, we will improve the representation’s legibility without sacriﬁcing its capacity for modelling nonlinear relationships.

Original: 2.1. V ARIATION
Revised: 2.1. V ARIATION

Original: During variation, the representations are perturbed using a set of mutation and crossover methods.
Revised: During variation, the representations are perturbed using a set of mutation and crossover methods.

Original: FEAT chooses among 6 variation operators that are as follows.
Revised: FEAT chooses among 6 variation operators that are as follows.

Original: Point mutation changes a node type to a random one with matching output type and arity.
Revised: Point mutation changes a node type to a random one with matching output type and arity.

Original: Insert mutation replaces a node with a randomly generated depth 1 subtree.
Revised: Insert mutation replaces a node with a randomly generated depth 1 subtree.

Original: Delete mutationwith equal probability, removes a feature ora replaces a sub-program with an input node.
Revised: Delete mutation removes a feature or replaces a sub-program with an input node, with equal probability.

Original: Insert/Delete dimension adds or removes a new feature.
Revised: Insert/Delete dimension adds or removes a new feature.

Original: Sub-tree crossover replaces a sub-tree from one parent with the sub-tree of another parent.
Revised: Sub-tree crossover replaces a sub-tree from one parent with the sub-tree of another parent.

Original: Dimension crossover swaps two features between parents.
Revised: Dimension crossover swaps two features between parents.

Original: The exact probabilities of each variation operator will affect the performance of the algorithm, and others have proposed methods for adjusting these probabilities, e.g. Igel & Kreutz (2003).
Revised: The exact probabilities of each variation operator will affect the performance of the algorithm, and others have proposed methods for adjusting these probabilities, e.g. Igel & Kreutz (2003).

Original: For the purposes of our study, we use each operator with uniform probability.
Revised: For the purposes of our study, we use each operator with uniform probability.

Original: Feedback The use of an ML model to assess the ﬁtness of each representation can be used to provide information about the elements of the representation that should be changed.
Revised: Feedback The use of an ML model to assess the ﬁtness of each representation can be used to provide information about the elements of the representation that should be changed.

Original: In particular, we assume that programs in the representation with small coefﬁcients are the best candidates for mutation and crossover.
Revised: In particular, we assume that programs in the representation with small coefﬁcients are the best candidates for mutation and crossover.

Original: With this in mind, let n be an m -dimensional candidate representation with associated coefﬁcients β ( n ) ∈ R m .
Revised: With this in mind, let n be an m -dimensional candidate representation with associated coefﬁcients β ( n ) ∈ R m .

Original: Let ˜ β
Revised: Let ˜ β

Original: i ( n ) = | β i | / (cid:80) mi | β i | .
Revised: i ( n ) = | β i | / (cid:80) mi | β i | .

Original: The probability of mutation for tree i in n is denoted PM i ( n ) , and deﬁned as follows:
Revised: The probability of mutation for tree i in n is denoted PM i ( n ) , and deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: The normalized coefﬁcient magnitudes ˜ β ∈ [0 , 1] are used to deﬁne softmax-normalized probabilities, s in Eqn.
Revised: The normalized coefﬁcient magnitudes ˜ β ∈ [0 , 1] are used to deﬁne softmax-normalized probabilities, s in Eqn.

Original: The smaller the coefﬁcient, the higher the probability of mutation.
Revised: The smaller the coefﬁcient, the higher the probability of mutation.

Original: The parameter f is used to control the amount of feedback used to weight the probabilities; 1 m in this case represents uniform probability.
Revised: The parameter f is used to control the amount of feedback used to weight the probabilities; 1 m in this case represents uniform probability.

Original: Among nodes in tree m , mutation occurs with uniform probability.
Revised: Among nodes in tree m , mutation occurs with uniform probability.

Original: This weighting could be extended for differentiable nodes by weighting the within-tree probabilities by the magnitude of the weights associated with each node.
Revised: This weighting could be extended for differentiable nodes by weighting the within-tree probabilities by the magnitude of the weights associated with each node.

Original: However we expect this would yield diminishing returns.
Revised: However we expect this would yield diminishing returns.

Original: 2.1. S ELECTION AND S URVIVAL
Revised: 2.1. S ELECTION AND S URVIVAL

Original: The selection step selects among P parents those representations that will be used to generate offspring.
Revised: The selection step selects among P parents those representations that will be used to generate offspring.

Original: Following variation, the population consists of 2 P representations of parents and offspring.
Revised: Following variation, the population consists of 2 P representations of parents and offspring.

Original: The survival step is used to reduce the population back to size P , at which point the generation is ﬁnished.
Revised: The survival step is used to reduce the population back to size P , at which point the generation is ﬁnished.

Original: In our initial study, we empirically compared ﬁve algorithms for selection and survival: 1) (cid:15) -lexicase selection (Lex) (La Cava et al., 2016), 2) non-dominated sorting genetic algorithm (NSGA2) (Deb et al., 2000), 3) a novel hybrid algorithm using Lex for selection and NSGA2 for survival, 4) simulated annealing (Kirkpatrick et al., 1983), and 5) random search.
Revised: In our initial study, we empirically compared ﬁve algorithms for selection and survival: 1) (cid:15) -lexicase selection (Lex) (La Cava et al., 2016b), 2) non-dominated sorting genetic algorithm (NSGA2) (Deb et al., 2000), 3) a novel hybrid algorithm using Lex for selection and NSGA2 for survival, 4) simulated annealing (Kirkpatrick et al., 1983), and 5) random search.

Original: These comparisons are described in Appendix Section A.2.
Revised: These comparisons are described in Appendix Section A.2.

Original: We found  the hybrid algorithm (3) to perform the best; it is described below.
Revised: We found that the hybrid algorithm (3) performed the best; it is described below.

Original: Parents are selected using Lex.
Revised: Parents are selected using Lex.

Original: Lex was proposed for regression problems (La Cava et al., 2016; 2018) as an adaption of lexicase selection (Spector, 2012) for continuous domains.
Revised: Lex was proposed for regression problems (La Cava et al., 2016b; 2018a) as an adaption of lexicase selection (Spector, 2012) for continuous domains.

Original: Under (cid:15) -lexicase selection, parents are chosen by ﬁltering the population according to randomized orderings of training samples with the (cid:15) threshold deﬁned relative to the sample loss among the  pool.
Revised: Under (cid:15) -lexicase selection, parents are chosen by ﬁltering the population according to randomized orderings of training samples with the (cid:15) threshold deﬁned relative to the sample loss among the selection pool.

Original: This ﬁltering strategy scales probability of selection for an individual based on the difﬁculty of the training cases the individual performs well on.
Revised: This ﬁltering strategy scales probability of selection for an individual based on the difﬁculty of the training cases the individual performs well on.

Original: Lex has shown strong performance among SR methods in recent tests, motivating our interest in studying it (Orzechowski et al., 2018).
Revised: Lex has shown strong performance among SR methods in recent tests, motivating our interest in studying it (Orzechowski et al., 2018).

Original: The survival step for Lex just preserves offspring plus the best individual in the population.
Revised: The survival step for Lex just preserves offspring plus the best individual in the population.

Original: Survival is conducted using the survival sub-routine of NSGA2, a popular strategy for multi-objective optimization (Deb et al., 2000).
Revised: Survival is conducted using the survival sub-routine of NSGA2, a popular strategy for multi-objective optimization (Deb et al., 2000).

Original: NSGA2 applies preference for survival using Pareto dominance relations.
Revised: NSGA2 applies preference for survival using Pareto dominance relations.

Original: An individual ( n i ) is said to dominate another ( n j ) if, for all objectives, n i performs at least as well as n j , and for at least one objective, n i strictly outperforms n j .
Revised: An individual ( n i ) is said to dominate another ( n j ) if, for all objectives, n i performs at least as well as n j , and for at least one objective, n i strictly outperforms n j .

Original: The Pareto front is the set of individuals in N that are non-dominated in the population and thus represent optimal trade-offs between objectives found during search.
Revised: The Pareto front is the set of individuals in N that are non-dominated in the population and thus represent optimal trade-offs between objectives found during search.

Original: Individuals are assigned a Pareto ranking that speciﬁes the number of individuals that dominate them, thereby determining their proximity to the front.
Revised: Individuals are assigned a Pareto ranking that speciﬁes the number of individuals that dominate them, thereby determining their proximity to the front.

Original: The survival step of NSGA2 begins by sorting the population according to their Pareto front ranking and choosing the lowest ranked individuals for survival.
Revised: The survival step of NSGA2 begins by sorting the population according to their Pareto front ranking and choosing the lowest ranked individuals for survival.

Original: To break rank ties, NSGA2 assigns each individual a crowding distance measure, which quantiﬁes an individual’s distance to its two adjacent neighbors in objective space.
Revised: To break rank ties, NSGA2 assigns each individual a crowding distance measure, which quantiﬁes an individual’s distance to its two adjacent neighbors in objective space.

Original: If a rank level does not completely ﬁt in the survivor pool, individuals of that rank are sorted by highest crowding distance and added in order until P individuals are chosen.
Revised: If a rank level does not completely ﬁt in the survivor pool, individuals of that rank are sorted by highest crowding distance and added in order until P individuals are chosen.

Original: 2.1. O BJECTIVES
Revised: 2.1. O BJECTIVES

Original: We consider three objectives in our study corresponding to three goals: ﬁrst, to reduce model error; second, to minimize complexity of the representation; and third, to minimize the entanglement of the representation.
Revised: We consider three objectives in our study corresponding to three goals: ﬁrst, to reduce model error; second, to minimize complexity of the representation; and third, to minimize the entanglement of the representation.

Original: We test the third objective using two different metrics: the correlation of the transformation matrix φ ( x ) and its condition number.
Revised: We test the third objective using two different metrics: the correlation of the transformation matrix φ ( x ) and its condition number.

Original: These metrics are deﬁned below.
Revised: These metrics are deﬁned below.

Original: The ﬁrst objective always corresponds to the mean squared loss function for individual n , and the second corresponds to the complexity of the representation.
Revised: The ﬁrst objective always corresponds to the mean squared loss function for individual n , and the second corresponds to the complexity of the representation.

Original: There are many ways to deﬁne complexity of an expression; one could simply look at the number of operations in a representation, or look at the behavioral complexity of the representation using a polynomial order (Vladislavleva et al., 2009).
Revised: There are many ways to deﬁne complexity of an expression; one could simply look at the number of operations in a representation, or look at the behavioral complexity of the representation using a polynomial order (Vladislavleva et al., 2009).

Original: The one we use, which is similar to that used by Kommenda et al. (2015), is to assign a complexity weight to each operator (see Table 1), with higher weights assigned to operators considered more complex.
Revised: The one we use, which is similar to that used by Kommenda et al. (2015), is to assign a complexity weight to each operator (see Table 1), with higher weights assigned to operators considered more complex.

Original: If the weight of operator o is c o , then the complexity of an expression tree beginning at node o is deﬁned recursively as
Revised: If the weight of operator o is c o , then the complexity of an expression tree beginning at node o is deﬁned recursively as

Original: [Equation]
Revised: [Equation]

Original: where o has k arguments, and C ( a ) is the complexity of argument a .
Revised: where o has k arguments, and C ( a ) is the complexity of argument a .

Original: The complexity of a representation is then deﬁned as the sum of the complexities of its output nodes.
Revised: The complexity of a representation is then deﬁned as the sum of the complexities of its output nodes.

Original: The goal of deﬁning complexity in such a way is to discourage deep sub-expressions within complex nodes, which are often hard to interpret.
Revised: The goal of deﬁning complexity in such a way is to discourage deep sub-expressions within complex nodes, which are often hard to interpret.

Original: It’s important to note that the choice of operator weights is bound to be subjective, since we lack an objective notion of interpretability.
Revised: It’s important to note that the choice of operator weights is bound to be subjective, since we lack an objective notion of interpretability.

Original: For this reason, although we use
Revised: For this reason, although we use

Original: Eqn. 4 to drive search, our experimental comparisons with other algorithms rely on the node counts of the ﬁnal models for benchmarking interpretability of different methods.
Revised: Eqn. 4 to drive search, our experimental comparisons with other algorithms rely on the node counts of the ﬁnal models for benchmarking interpretability of different methods.

Original: Disentanglement is a term used to describe the notion of a representation’s ability to separate factors of variation in the underlying process (Bengio et al., 2013).
Revised: Disentanglement is a term used to describe the notion of a representation’s ability to separate factors of variation in the underlying process (Bengio et al., 2013).

Original: Although a thorough review is beyond the scope of this section, there is a growing body of literature addressing disentanglement, primarily with unsupervised learning and/or image analysis (Montavon & Müller, 2012; Whitney, 2016;
Revised: Although a thorough review is beyond the scope of this section, there is a growing body of literature addressing disentanglement, primarily with unsupervised learning and/or image analysis (Montavon & Müller, 2012; Whitney, 2016;

Original: Higgins et al., 2017; Gonzalez-Garcia et al., 2018; Hadad et al., 2018; Kumar et al., 2018).
Revised: Higgins et al., 2017; Gonzalez-Garcia et al., 2018; Hadad et al., 2018; Kumar et al., 2018).

Original: There are various ways to quantify disentanglement.
Revised: There are various ways to quantify disentanglement.

Original: For instance, Brahma et al.
Revised: For instance, Brahma et al.

Original: (2016) proposed measuring disentanglement as the difference between geodesic and Euclidean distances among points on a manifold (i.e. training instances).
Revised: (2016) proposed measuring disentanglement as the difference between geodesic and Euclidean distances among points on a manifold (i.e. training instances).

Original: If the latent structure is known, the information-theoretic metrics proposed by Eastwood & Williams (2018) may be used.
Revised: If the latent structure is known, the information-theoretic metrics proposed by Eastwood & Williams (2018) may be used.

Original: In the case of regression, a disentangled representation ideally contains a minimal set of features, each corresponding to a separate latent factor of variation, and each orthogonal to each other.
Revised: In the case of regression, a disentangled representation ideally contains a minimal set of features, each corresponding to a separate latent factor of variation, and each orthogonal to each other.

Original: In this regard, we attempt to minimize the collinearity between features in φ as a way to promote disentanglement.
Revised: In this regard, we attempt to minimize the collinearity between features in φ as a way to promote disentanglement.

Original: We tested two measurements of collinearity (a.k.a. multicollinearity) in the derived feature space.
Revised: We tested two measurements of collinearity (a.k.a. multicollinearity) in the derived feature space.

Original: The ﬁrst is the average squared
Revised: The ﬁrst is the average squared

Original: Pearson’s correlation among features of φ , i.e.,
Revised: Pearson’s correlation among features of φ , i.e.,

Original: [Equation]
Revised: [Equation]

Original: Eqn. 5 is relatively inexpensive to compute but only captures bivariate correlations in φ .
Revised: Eqn. 5 is relatively inexpensive to compute but only captures bivariate correlations in φ .

Original: As a result we also test the condition number (CN).
Revised: As a result we also test the condition number (CN).

Original: Consider the N × m representation matrix Φ .
Revised: Consider the N × m representation matrix Φ .

Original: The CN of Φ is deﬁned as
Revised: The CN of Φ is deﬁned as

Original: [Equation]
Revised: [Equation]

Original: where µ max and µ min are the largest and smallest singular values of Φ .
Revised: where µ max and µ min are the largest and smallest singular values of Φ .

Original: Unlike Corr , CN can capture higher-order dependencies in the representation.
Revised: Unlike Corr , CN can capture higher-order dependencies in the representation.

Original: CN is also related directly to the sensitivity of Φ to perturbations in the training data (Belsley, 1991; Cline et al., 1979), and thus captures a notion of network invariance explored in previous work by Goodfellow et al.
Revised: CN is also related directly to the sensitivity of Φ to perturbations in the training data (Belsley, 1991; Cline et al., 1979), and thus captures a notion of network invariance explored in previous work by Goodfellow et al.

Original: We consider another common measure of multicollinearity, the variance inﬂation factor (O’brien, 2007), to be too expensive for our purposes.
Revised: We consider another common measure of multicollinearity, the variance inﬂation factor (O’brien, 2007), to be too expensive for our purposes.

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

Original: The idea to evolve NN architectures is well established in literature, and is known as neuroevolution.
Revised: The idea to evolve NN architectures is well established in literature, and is known as neuroevolution.

Original: Popular methods of neuroevolution include neuroevolution of augmenting topologies (NEAT(Stanley & Miikkulainen, 2002) and Hyper-NEAT(Stanley et al., 2009)), and compositional pattern producing networks (Stanley, 2007) .
Revised: Popular methods of neuroevolution include neuroevolution of augmenting topologies (NEAT(Stanley & Miikkulainen, 2002) and Hyper-NEAT(Stanley et al., 2009)), and compositional pattern producing networks (Stanley, 2007) .

Original: The aforementioned approaches eschew the parameter learning step common in other NN paradigms, although others have developed integrations (Fernando et al., 2016).
Revised: The aforementioned approaches eschew the parameter learning step common in other NN paradigms, although others have developed integrations (Fernando et al., 2016).

Original: In addition, they have been developed predominantly for other task domains such as robotics and control (Gomez et al., 2006), image classiﬁcation (Real et al., 2017; Real, 2018), and reinforcement learning (Igel, 2003; Conti et al., 2017).
Revised: In addition, they have been developed predominantly for other task domains such as robotics and control (Gomez et al., 2006), image classiﬁcation (Real et al., 2017; Real, 2018), and reinforcement learning (Igel, 2003; Conti et al., 2017).

Original: A review of these methods is available (Floreano et al., 2008).
Revised: Reviews of these methods are available (Floreano et al., 2008; Stanley et al., 2019).

Original: Most neuroevolution strategies do not have interpretability as a core focus, and thus do not attempt to use multi-objective methods to update the networks.
Revised: Most neuroevolution strategies do not have interpretability as a core focus, and thus do not attempt to use multi-objective methods to update the networks.

Original: An exception is the work of Wiegand et al.
Revised: An exception is the work of Wiegand et al.

Original: (2004), in which a template NN was optimized using a multi-objective EC method with size as an objective.
Revised: (2004), in which a template NN was optimized using a multi-objective EC method with size as an objective.

Original: In this case, the goal was to reduce computational complexity in face detection.
Revised: In this case, the goal was to reduce computational complexity in face detection.

Original: Neuroevolution is a part of a broader research ﬁeld of neural architecture search (NAS) (Zoph & Le, 2016; Le & Zoph, 2017; Liu et al., 2017).
Revised: Neuroevolution is a part of a broader research ﬁeld of neural architecture search (NAS) (Zoph & Le, 2016; Le & Zoph, 2017; Liu et al., 2017).

Original: NAS methods vary in approach, including for example parameter sharing (Pham et al., 2018), sequential model-based optimization (Liu et al., 2017), reinforcement learning (Zoph & Le, 2016), and greedy heuristic strategies (Cortes et al., 2016).
Revised: NAS methods vary in approach, including for example parameter sharing (Pham et al., 2018), sequential model-based optimization (Liu et al., 2017), reinforcement learning (Zoph & Le, 2016), and greedy heuristic strategies (Cortes et al., 2016).

Original: FEAT is also related to SR approaches to feature engineering (Krawiec, 2002; Arnaldo et al., 2014;
Revised: FEAT is also related to SR approaches to feature engineering (Krawiec, 2002; Arnaldo et al., 2014;

Original: La Cava & Moore, 2017) that use EC to search for possible representations and couple with an ML model to handle the parametrization of the representations.
Revised: La Cava & Moore, 2017; La Cava et al., 2018b; Muñoz et al., 2018) that use EC to search for possible representations and couple with an ML model to handle the parametrization of the representations.

Original: SR methods have been successful in developing intelligible models of physical systems (Schmidt & Lipson, 2009).
Revised: SR methods have been successful in developing intelligible models of physical systems (Schmidt & Lipson, 2009; La Cava et al., 2016a).

Original: FEAT differs from these methods in the following ways.
Revised: FEAT differs from these methods in the following ways.

Original: A key challenge in SR is understanding functional modularity within representations/programs that can be exploited for search.
Revised: A key challenge in SR is understanding functional modularity within representations/programs that can be exploited for search.

Original: FEAT is designed with the insight that ML weights can be leveraged during variation to promote functional building blocks, an exploit not used in previous methods.
Revised: FEAT is designed with the insight that ML weights can be leveraged during variation to promote functional building blocks, an exploit not used in previous methods.

Original: Second, FEAT uses multiple type representations, and thus can learn continuous and rule-based features within a single representation, unlike previous methods.
Revised: Second, FEAT uses multiple type representations, and thus can learn continuous and rule-based features within a single representation, unlike previous methods.

Original: This is made possible using a stack-based encoding with strongly-typed operators.
Revised: This is made possible using a stack-based encoding with strongly-typed operators.

Original: Finally, FEAT incorporates two elements of NN learning to improve its representational capacity: activation functions commonly used in NN and edge-based encoding of weights.
Revised: Finally, FEAT incorporates two elements of NN learning to improve its representational capacity: activation functions commonly used in NN and edge-based encoding of weights.

Original: Traditionally, SR operates with standard mathematical operators, and treats constants as leaves in the expression trees rather than edge weights.
Revised: Traditionally, SR operates with standard mathematical operators, and treats constants as leaves in the expression trees rather than edge weights.

Original: An exception is MRGP (Arnaldo et al., 2014), which encodes weights at each node but updates them via Lasso instead of using gradient descent with backpropagation.
Revised: An exception is MRGP (Arnaldo et al., 2014), which encodes weights at each node but updates them via Lasso instead of using gradient descent with backpropagation.

Original: SR methods have also been paired with various parameter learning strategies, including those based on backpropagation (Topchy & Punch, 2001; Kommenda et al., 2013; Izzo et al., 2017).
Revised: SR methods have also been paired with various parameter learning strategies, including those based on backpropagation (Topchy & Punch, 2001; Kommenda et al., 2013; Izzo et al., 2017).

Original: It should be noted that non-stochastic methods for SR exist, such as mixed integer non-linear programming, which has been demonstrated for small search spaces (Austel et al., 2017).
Revised: It should be noted that non-stochastic methods for SR exist, such as mixed integer non-linear programming, which has been demonstrated for small search spaces (Austel et al., 2017).

Original:  E XPERIMENT
Revised:  E XPERIMENT

Original: [Figure] Our goals with the experiment are to 1) robustly compare FEAT to state-of-the-art regression methods, including hyperparameter optimization of feedforward NNs; 2) characterize the complexity of the models; and 3) assess whether disentanglement objectives lead to less correlated representations.
Revised: Our goals with the experiment are to 1) robustly compare FEAT to state-of-the-art regression methods, including hyperparameter optimization of feedforward NNs; 2) characterize the complexity of the models; and 3) assess whether disentanglement objectives lead to less correlated representations.

Original: For the regression datasets, we use 100 real-world and simulated datasets available from OpenML (Vanschoren et al., 2014).
Revised: For the regression datasets, we use 100 real-world and simulated datasets available from OpenML (Vanschoren et al., 2014).

Original: The datasets are characterized in terms of number of features and sample sizes in Figure 2.
Revised: The datasets are characterized in terms of number of features and sample sizes in Figure 2.

Original: We use the standardized versions of the datasets available in the Penn Machine Learning Benchmark repository (Olson et al., 2017).
Revised: We use the standardized versions of the datasets available in the Penn Machine Learning Benchmark repository (Olson et al., 2017).

Original: We compare the FEAT conﬁgurations to multi-layer perceptron (MLP), random forest (RF) regression, kernel ridge (KernelRidge) regression, and elastic net (ElasticNet) regression, using implementations from scikit-learn (Pedregosa et al., 2011).
Revised: We compare the FEAT conﬁgurations to multi-layer perceptron (MLP), random forest (RF) regression, kernel ridge (KernelRidge) regression, and elastic net (ElasticNet) regression, using implementations from scikit-learn (Pedregosa et al., 2011).

Original: In addition, we compare to XGBoost (XGB), a gradient boosting method that has performed well in recent competitions (Chen & Guestrin, 2016).
Revised: In addition, we compare to XGBoost (XGB), a gradient boosting method that has performed well in recent competitions (Chen & Guestrin, 2016).

Original: Code to reproduce these experiments is available online.
Revised: Code to reproduce these experiments is available online.

Original: Each method’s hyperparameters are tuned according to Table 2 in Appendix A.1.

Original: For FEAT, we limit optimization to 200 iterations or 60 minutes, whichever comes ﬁrst.

Original: We also stop sooner if the median

Original: F ea t
Revised: F ea t

Original: F ea t C
Revised: F ea t C

Original: o
Revised: o

Original: rr F ea t C N
Revised: rr F ea t C N

Original: X G B
Revised: X G B

Original: R F
Revised: R F

Original: M L P
Revised: M L P

Original: K e r n e l R i d g e
Revised: K e r n e l R i d g e

Original: E l a s t i c N e t 0.
Revised: E l a s t i c N e t 0.

Original: S c
Revised: S c

Original: o r e ( N o r m a li z ed
Revised: o r e ( N o r m a li z ed

Original: R 2 )
Revised: R 2 )

Original: F ea t
Revised: F ea t

Original: F ea t C
Revised: F ea t C

Original: o
Revised: o

Original: rr F ea t C N
Revised: rr F ea t C N

Original: X G B
Revised: X G B

Original: R F
Revised: R F

Original: M L P
Revised: M L P

Original: E l a s t i c N e t 
 
Revised: E l a s t i c N e t 
 S i

Revised: [Figure]

Original: S i z e
Revised: ( # node [Figure] Each method’s hyperparameters are tuned according to Table 2 in Appendix A.1. For FEAT, we limit optimization to 200 iterations or 60 minutes, whichever comes ﬁrst.

Original: ( # node s ) validation ﬁtness stops improving.
Revised: We also stop sooner if the median validation ﬁtness stops improving.

Original: For each method, we use grid search to tune the hyperparameters with 10-fold cross validation (CV).
Revised: For each method, we use grid search to tune the hyperparameters with 10-fold cross validation (CV).

Original: We use the R 2 CV score for assessing performance.
Revised: We use the R 2 CV score for assessing performance.

Original: In our results we report the CV scores for each method using its best hyperparameters.
Revised: In our results we report the CV scores for each method using its best hyperparameters.

Original: The algorithms are ranked on each dataset using their median CV score over 5 randomized shufﬂes of the dataset.
Revised: The algorithms are ranked on each dataset using their median CV score over 5 randomized shufﬂes of the dataset.

Original: For comparing complexity, we count the number of nodes in the ﬁnal model produced by each method for each trial on each dataset.
Revised: For comparing complexity, we count the number of nodes in the ﬁnal model produced by each method for each trial on each dataset.

Original: To quantify the "entanglement" of the feature spaces, we report Eqn. 5 in the raw data and in the ﬁnal hidden layer of FEAT and MLP models.
Revised: To quantify the "entanglement" of the feature spaces, we report Eqn. 5 in the raw data and in the ﬁnal hidden layer of FEAT and MLP models.

Original: We also test two additional versions of Feat, denoted FeatCorr and FeatCN, that include a third objective corresponding to Eqn.
Revised: We also test two additional versions of Feat, denoted FeatCorr and FeatCN, that include a third objective corresponding to Eqn.

Original: 5 and 6, respectively.
Revised: 5 and 6, respectively.

Revised: [Figure]

Original: Finally, we examine the FEAT results in detail for one of the benchmark datasets.
Revised: Finally, we examine the FEAT results in detail for one of the benchmark datasets.

Original: For this dataset we plot the ﬁnal population of models, illustrate model selection and compare the resultant features to results from linear and ensemble tree-based results.
Revised: For this dataset we plot the ﬁnal population of models, illustrate model selection and compare the resultant features to results from linear and ensemble tree-based results.

Original: This gives practical insight into the method and provides a sense of the intelligibility of an example representation.
Revised: This gives practical insight into the method and provides a sense of the intelligibility of an example representation.

Original:  R ESULTS
Revised:  R ESULTS

Original: The score statistics for each method are shown in Fig.
Revised: The score statistics for each method are shown in Fig.

Original: 3 across all datasets.
Revised: 3 across all datasets.

Original: Full statistical comparisons are reported in Appendix A.3.
Revised: Full statistical comparisons are reported in Appendix A.3.

Original: Over all, FEAT and XGBoost produce the best predictive performance across datasets without signiﬁcant differences between the two ( p =1.0).
Revised: Over all, FEAT and XGBoost produce the best predictive performance across datasets without signiﬁcant differences between the two ( p =1.0).

Original: FEAT signiﬁcantly outperforms MLP, RF, KernelRidge and ElasticNet ( p ≤ 1.2e-3), as does XGBoost ( p ≤ 1.46e-4).
Revised: FEAT signiﬁcantly outperforms MLP, RF, KernelRidge and ElasticNet ( p ≤ 1.18e-4), as does XGBoost ( p ≤ 1.6e-3).

Original: As measured by the number of nodes in the ﬁnal solutions, the models produced by FEAT are signiﬁcantly less complex than XGBoost, RF, and MLP, as shown in Fig.
Revised: As measured by the number of nodes in the ﬁnal solutions, the models produced by FEAT are signiﬁcantly less complex than XGBoost, RF, and MLP, as shown in Fig.

Original: 4 ( p <1e-16).
Revised: 4 ( p <1e-16).

Original: FEAT’s ﬁnal models tend to be within 1 order of magnitude of the linear models (ElasticNet), and 2-4 orders of magnitude smaller than the other non-linear methods.
Revised: FEAT’s ﬁnal models tend to be within 1 order of magnitude of the linear models (ElasticNet), and 2-4 orders of magnitude smaller than the other non-linear methods.

Original: A comparison of wall-clock time is given in Fig.
Revised: A comparison of wall-clock time is given in Fig.

Original: 7 in the appendix.
Revised: 7 in the appendix.

Original: FEAT and MLP take approximately the same time to run, followed by XGBoost, RF, KernelRidge, and ElasticNet, in that order.
Revised: FEAT and MLP take approximately the same time to run, followed by XGBoost, RF, KernelRidge, and ElasticNet, in that order.

Original: Fig.
Revised: Fig.

Original: 5 shows the average pairwise correlations of the representations produced by Feat variants and
Revised: 5 shows the average pairwise correlations of the representations produced by Feat variants and

Original: MLP in comparison to the correlation structure of the original data.
Revised: MLP in comparison to the correlation structure of the original data.

Original: In general, MLP and FEAT tend to produce correlated feature spaces, and Feat’s representations tend to contain more bivariate correlations than MLP.
Revised: In general, MLP and FEAT tend to produce correlated feature spaces, and Feat’s representations tend to contain more bivariate correlations than MLP.

Original: Furthermore, the results suggest that explicitly minimizing collinearity(FeatCorr and FeatCN) tends to produce representations that exhibit higher correlations. This result conﬂicts with our hypothesis, and is discussed more in Section 6. Illustrative Example We show an illustrative example of the ﬁnal archive and model selection process from applying FEAT to a galaxy visualization dataset (Cleveland, 1993) in Figure 6. The red and blue points correspond to training and validation scores for each archived representation with a square denoting the ﬁnal model selection.
Revised: Furthermore, the results suggest that explicitly minimizing collinearity

Original: Five of the representations are printed in plain text, with each feature separated by brackets. The vertical lines in the left ﬁgure denote the test scores for MSE C o m p l e x i t y
Revised: [Figure]

Original: [ x 1 ] [ x 1 ][ x 2 ][ x 0 ][ x 1 ][ x 3 ] [ tanh ( x 0 )]
Revised: [ x 1 ] [ x 1 ][ x 2 ][ x 0 ][ x 1 ][ x 3 ] [ tanh ( x 0 )]

Original: [ tanh ( x 1 )]
Revised: [ tanh ( x 1 )]

Original: [ tanh ( x 1 )][ x 3 ][ x 2 ][ tanh ( x 0 )] [( x 2 * x 0 )] [ tanh ( x 1 )][ x 3 ][ x 2 ][ tanh ( x 0 )]
Revised: [ tanh ( x 1 )][ x 3 ][ x 2 ][ tanh ( x 0 )] [( x 2 * x 0 )] [Figure]

Original: [(( x 1 * x 0 )*( x 3 x 0 ))] [( x 23 )] [ x 1 ][((
Revised: [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: φ ( x ) β tanh( x 1 ) 2953.
Revised: φ ( x ) β tanh( x 1 ) 2953.

Original: x1961.
Revised: x1961.

Original: ( x 23 ) 329.
Revised: ( x 23 ) 329.

Original: tanh( x 0 )
Revised: tanh( x 0 )

Revised: (( x

Revised: [Figure]

Original: (( x 1 · x 0 ) · ( x 3 − x 0 )) 303.
Revised: · x 0 ) · ( x [Figure] − x 0 )) 303.

Original: (( x 23 ) 2 )
Revised: (( x 23 ) 2 )

Original: x203.
Revised: x203.

Original: x64.
Revised: x64.

Original: FEAT, RF and ElasticNet.
Revised: (FeatCorr and FeatCN) tends to produce representations that exhibit equivalent or higher levels of correlation. This result conﬂicts with our hypothesis, and is discussed more in Section 6. [Figure] Illustrative Example We show an illustrative example of the ﬁnal archive and model selection process from applying FEAT to a galaxy visualization dataset (Cleveland, 1993) in Figure 6.

Revised: The red and blue points correspond to training and validation scores for each archived representation with a square denoting the ﬁnal model selection.

Revised: Five of the representations are printed in plain text, with each feature separated by brackets.

Revised: The vertical lines in the left ﬁgure denote the test scores for FEAT, RF and

Original:  It is interesting to note that ElasticNet performance roughly matches the performance of a linear representation, and the RF test performance corresponds to the representation [tanh( x 0 )]
Revised: ElasticNet. It is interesting to note that ElasticNet performance roughly matches the performance of a linear representation, and the RF test performance corresponds to the representation [tanh( x 0 )]

Original: [tanh( x 1 )] that is suggestive of axis-aligned splits for x 0 and x 1 .
Revised: [tanh( x 1 )] that is suggestive of axis-aligned splits for x 0 and x 1 .

Original: The selected model is shown on the right, with the features sorted according to the magnitudes of β in the linear model.
Revised: The selected model is shown on the right, with the features sorted according to the magnitudes of β in the linear model.

Original: The ﬁnal representation combines tanh, polynomial, linear and interacting features.
Revised: The ﬁnal representation combines tanh, polynomial, linear and interacting features.

Original: This representation is a clear extension of simpler ones in the archive, and the archive thereby serves to characterize the improvement in predictive accuracy brought about by increasing complexity.
Revised: This representation is a clear extension of simpler ones in the archive, and the archive thereby serves to characterize the improvement in predictive accuracy brought about by increasing complexity.

Original: Although a mechanistic interpretation requires domain expertise, the ﬁnal representation is certainly concise and amenable to interpretation.
Revised: Although a mechanistic interpretation requires domain expertise, the ﬁnal representation is certainly concise and amenable to interpretation.

Original:  D ISCUSSION AND C ONCLUSION
Revised:  D ISCUSSION AND C ONCLUSION

Original: F ea t

Original: F ea t C

Original: o

Original: rr

Original: F ea t CN M L P [Figure] This paper proposes a feature engineering archive tool that optimizes neural network architectures by representing them as syntax trees.
Revised: This paper proposes a feature engineering archive tool that optimizes neural network architectures by representing them as syntax trees.

Original: FEAT uses model weights as feedback to guide network variation in an EC optimization algorithm.
Revised: FEAT uses model weights as feedback to guide network variation in an EC optimization algorithm.

Original: We conduct a thorough analysis of this method applied to the task of regression in comparison to state-ofthe-art methods.
Revised: We conduct a thorough analysis of this method applied to the task of regression in comparison to state-of-the-art methods.

Original: The results suggest that FEAT achieves state-of-the-art performance on regression tasks while producing representations that are signiﬁcantly less complex than those resulting from similarly performing methods.
Revised: The results suggest that FEAT achieves state-of-the-art performance on regression tasks while producing representations that are signiﬁcantly less complex than those resulting from similarly performing methods.

Original: This improvement comes at an additional computational cost, limited in this study to 60 minutes per training instance.
Revised: This improvement comes at an additional computational cost, limited in this study to 60 minutes per training instance.

Original: We expect this limitation to be reasonable for many applications where intelligibility is the prime motivation.
Revised: We expect this limitation to be reasonable for many applications where intelligibility is the prime motivation.

Original: Future work should consider the issue of representation disentanglement in more depth.
Revised: Future work should consider the issue of representation disentanglement in more depth.

Original: Our attempts to include additional search objectives that explicitly minimize multicollinearity resulted in ﬁnal representations with higher correlations on the test data.
Revised: Our attempts to include additional search objectives that explicitly minimize multicollinearity were not successful.

Original: Although more analysis is needed to conﬁrm this, we suspect that the model selection procedure (Section 2.1, step 3) permits highly collinear representations to be chosen.
Revised: Although more analysis is needed to conﬁrm this, we suspect that the model selection procedure (Section 2.1, step 3) permits highly collinear representations to be chosen.

Original: This is because multicollinearity primarily affects the standard errors of ˆ β (Belsley, 1991), and is not necessarily detrimental to validation error.
Revised: This is because multicollinearity primarily affects the standard errors of ˆ β (Belsley, 1991), and is not necessarily detrimental to validation error.

Original: Therefore it could be incorrect to expect the model selection procedure to effectively choose more disentangled representations.
Revised: Therefore it could be incorrect to expect the model selection procedure to effectively choose more disentangled representations.

Original: Besides improving the model selection procedure, it may be fruitful to pressure disentanglement at other stages of the search process.
Revised: Besides improving the model selection procedure, it may be fruitful to pressure disentanglement at other stages of the search process.

Original: For example, the variation process could prune highly correlated features, or the disentanglement metric could be combined with error into a single loss function with a tuneable parameter.
Revised: For example, the variation process could prune highly correlated features, or the disentanglement metric could be combined with error into a single loss function with a tunable parameter.

Original: We hope to pursue these ideas in future studies.
Revised: We hope to pursue these ideas in future studies.

Revised:  A CKNOWLEDGMENTS

Revised: This work was supported by NIH grants AI116794 and LM

Original: A A PPENDIX A. A DDITIONAL E XPERIMENT I NFORMATION
Revised: A A PPENDIX A. A DDITIONAL E XPERIMENT I NFORMATION

Original: Table 2 details the hyperparameters for each method used in the experimental results described in
Revised: Table 2 details the hyperparameters for each method used in the experimental results described in

Original: Sections 4 and [Table]
Revised: Sections 4 and 5.

Original: Runs are conducted in a heterogenous computing environment [Table] with one core assigned to each CV training per dataset.
Revised: Runs are conducted in a heterogenous computing environment, with one core assigned to each CV training per dataset.

Original: As such, wall-clock times are a ﬂawed measure of computational complexity
Revised: As such, wall-clock times are a ﬂawed measure of computational complexity.

Original: [Table]

Original: With this caveat in mind, we report the wall-clock run times for each method in Fig.
Revised: With this caveat in mind, we report the wall-clock run times for each method in Fig.

Original: The Feat variants are terminated at 200 generations or 60 minutes, which explains their uniformity.
Revised: The Feat variants are terminated at 200 generations or 60 minutes, which explains their uniformity.

Original: Note that methods are unable to take advantage of parallelization in this experiment.
Revised: Note that methods are unable to take advantage of parallelization in this experiment.

Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: A. C OMPARISON OF STOCHASTIC OPTIMIZATION APPROACHES
Revised: A. C OMPARISON OF STOCHASTIC OPTIMIZATION APPROACHES

Original: Our initial analysis sought to determine how different SO approaches performed within this framework.
Revised: Our initial analysis sought to determine how different SO approaches performed within this framework.

Original: We tested ﬁve methods: 1) NSGA2, 2)
Revised: We tested ﬁve methods: 1) NSGA2, 2)

Original: Lex, 3) LexNSGA2, 4) Simulated annealing, and 5) random search.
Revised: Lex, 3) LexNSGA2, 4) Simulated annealing, and 5) random search.

Original: The simulated annealing and random search approaches are described below.
Revised: The simulated annealing and random search approaches are described below.

Original: Simulated annealing Simulated annealing (SimAnn) is a non-evolutionary technique that instead models the optimization process on the metallurgical process of annealing.
Revised: Simulated annealing Simulated annealing (SimAnn) is a non-evolutionary technique that instead models the optimization process on the metallurgical process of annealing.

Original: In our implementation, offspring compete with their parents; in the case of multiple parents, offspring compete with the program with which they share more nodes.
Revised: In our implementation, offspring compete with their parents; in the case of multiple parents, offspring compete with the L e x N S G A L e x N S G A

Original: The probability of an offspring replacing its parent in the population is given by the equation
Revised: S i m A nn e a l R a n do m 0. S c o r e ( N o r m a li z ed

Revised: R 2 )

Revised: L e x N S G A

Revised: L e x

Revised: N S G A

Revised: S i m A nn e a l

Original: {+R a n do m 
+}
Revised: {+R a n do m 
+}

Revised: S i z e

Revised: ( # node s ) program with which they share more nodes.

Revised: The probability of an offspring replacing its parent in the population is given by the equation

Original: [Equation]
Revised: [Equation]

Original: The probability of offspring replacing its parent is a function of its ﬁtness,  in our case the mean squared loss of the candidate model.
Revised: The probability of offspring replacing its parent is a function of its ﬁtness, F , in our case the mean squared loss of the candidate model.

Original: In Eqn. 7, t is a scheduling parameter that controls the rate of “cooling", i.e. the rate at which steps in the search space that are worse are tolerated by the update rule.
Revised: In Eqn. 7, t is a scheduling parameter that controls the rate of “cooling", i.e. the rate at which steps in the search space that are worse are tolerated by the update rule.

Original: In accordance with (Kirkpatrick et al., 1983), we use an exponential schedule for t , deﬁned as t g = (0 . 9) g t 0 , where g is the current generation and t 0 is the starting temperature.
Revised: In accordance with (Kirkpatrick et al., 1983), we use an exponential schedule for t , deﬁned as t g = (0 . 9) g t 0 , where g is the current generation and t 0 is the starting temperature.

Original: t 0 is set to 10 in our experiments.
Revised: t 0 is set to 10 in our experiments.

Original: Random search We compare the selection and survival methods to random search, in which no assumptions are made about the structure of the search space.
Revised: Random search We compare the selection and survival methods to random search, in which no assumptions are made about the structure of the search space.

Original: To conduct random search, we randomly sample S using the initialization procedure described above.
Revised: To conduct random search, we randomly sample S using the initialization procedure.

Original: Since FEAT begins with a linear model of the process, random search will produce a representation at least as good as this initial model on the internal validation set.
Revised: Since FEAT begins with a linear model of the process, random search will produce a representation at least as good as this initial model on the internal validation set.

Original: A note on archiving When FEAT is used without a complexity-aware survival method (i.e., with Lex, SimAnn, Random), a separate population is maintained that acts as an archive.
Revised: A note on archiving When FEAT is used without a complexity-aware survival method (i.e., with Lex, SimAnn, Random), a separate population is maintained that acts as an archive.

Original: The archive maintains a Pareto front according to minimum loss and complexity (Eqn 4).
Revised: The archive maintains a Pareto front according to minimum loss and complexity (Eqn 4).

Original: At the end of optimization, the archive is tested on a small hold-out validation set.
Revised: At the end of optimization, the archive is tested on a small hold-out validation set.

Original: The individual with the lowest validation loss is the ﬁnal selected model.
Revised: The individual with the lowest validation loss is the ﬁnal selected model.

Original: Maintaining this archive helps protect against overﬁtting resulting from overly complex / high capacity representations, and also can be interpreted directly to help understand the process being modelled.
Revised: Maintaining this archive helps protect against overﬁtting resulting from overly complex / high capacity representations, and also can be interpreted directly to help understand the process being modelled.

Original: We benchmarked these approaches in a separate experiment on 88 datasets from PMLB (Olson et al., 2017).
Revised: We benchmarked these approaches in a separate experiment on 88 datasets from PMLB (Olson et al., 2017).

Original: The results are shown in Figures8-11.
Revised: The results are shown in Figures 8-11.

Original: Considering Figures 8 and 9, we see that LexNSGA achieves the best average R 2 value while producing small solutions in comparison to Lex.
Revised: Considering Figures 8 and 9, we see that LexNSGA achieves the best average R 2 value while producing small solutions in comparison to Lex.

Original: NSGA2,
Revised: NSGA2,

Original: L e x N S G A

Original: L e x

Original: N S G A

Original: S i m A nn e a l

Original: R a n do m

Original: [Figure]

Original: [Figure]

Original: S c

Original: o r e ( N o r m a li z ed

Original: R 2 )

Original: [Figure] [Figure] [Figure] SimAnneal, and Random search all produce less accurate models.
Revised: SimAnneal, and Random search all produce less accurate models.

Original: The runtime comparisons of the methods in Figure 10 show that they are mostly within an order of magnitude, with NSGA2 being the fastest (due to its maintenance of small representations) and Random search being the slowest, suggesting that it maintains large representations during search.
Revised: The runtime comparisons of the methods in Figure 10 show that they are mostly within an order of magnitude, with NSGA2 being the fastest (due to its maintenance of small representations) and Random search being the slowest, suggesting that it maintains large representations during search.

Original: The computational behavior of
Revised: The computational behavior of

Original: Random search suggests the variation operators tend to increase the average size of solutions over many iterations
Revised: Random search suggests the variation operators tend to increase the average size of solutions over many iterations.

Original: [Figure]

Original: A. S TATISTICAL C OMPARISONS
Revised: A. S TATISTICAL C OMPARISONS

Original: We  pairwise comparisons of methods according to the procedure recommended by Demšar (2006) for comparing multiple estimators.
Revised: We perform pairwise comparisons of methods according to the procedure recommended by Demšar (2006) for comparing multiple estimators.

Original: In Table 3, the CV R 2 rankings are compared. 
Revised: In Table 3, the CV R 2 rankings are compared. In

Revised: L e x N S G A

Revised: L e x

Revised: N S G A

Original: In Table 4, the best model size rankings are compared.{+S i m A nn e a l R a n do m 
 T i m e ( s ) L e x N S G A+}
Revised: {+S i m A nn e a l R a n do m 
 T i m e ( s ) L e x N S G A+}

Revised: L e x

Revised: N S G A

Revised: S i m A nn e a l

Revised: R a n do m 0.

Revised: M ean

Revised: R ep r e s en t a t i on

Revised: C o rr e l a t i on

Revised: Table 4, the best model size rankings are compared.

Original: Note that KernelRidge is omitted from the size comparisons since we don’t have a comparable way of measuring the model size.
Revised: Note that KernelRidge is omitted from the size comparisons since we don’t have a comparable way of measuring the model size

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