Original: RRL: A S CALABLE C LASSIFIER FOR I NTERPRETABLE R ULE -B ASED R EPRESENTATION L EARNING
Revised: RRL: A S CALABLE C LASSIFIER FOR I NTERPRETABLE R ULE -B ASED R EPRESENTATION L EARNING

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Rule-based models, e.g., decision trees, are widely used in scenarios demanding high model interpretability for their transparent inner structures and good model expressivity.
Revised: Rule-based models, e.g., decision trees, are widely used in scenarios demanding high model interpretability for their transparent inner structures and good model expressivity.

Original: However, rule-based models are hard to optimize, especially on large data sets, due to their discrete parameters and structures.
Revised: However, rule-based models are hard to optimize, especially on large data sets, due to their discrete parameters and structures.

Original: Ensemble methods and fuzzy/soft rules are commonly used to tackle these issues, but they sacriﬁce the model interpretability.
Revised: Ensemble methods and fuzzy/soft rules are commonly used to tackle these issues, but they sacriﬁce the model interpretability.

Original: In this paper, we propose a new classiﬁer, named Rulebased Representation Learner (RRL), that automatically learns interpretable nonfuzzy rules for data representation.
Revised: In this paper, we propose a new classiﬁer, named Rulebased Representation Learner (RRL), that automatically learns interpretable nonfuzzy rules for data representation.

Original: To train the non-differentiable RRL effectively, we project it to a continuous space and propose a novel training method, called
Revised: To train the non-differentiable RRL effectively, we project it to a continuous space and propose a novel training method, called

Original: Gradient Grafting, that can directly optimize the discrete model using gradient descent.
Revised: Gradient Grafting, that can directly optimize the discrete model using gradient descent.

Original: An improved design of logical activation functions is also devised to increase the scalability of RRL and enable it to discretize the continuous features end-to-end.
Revised: An improved design of logical activation functions is also devised to increase the scalability of RRL and enable it to discretize the continuous features end-to-end.

Original: Exhaustive experiments on 9 small and 4 large data sets show that
Revised: Exhaustive experiments on 9 small and 4 large data sets show that

Original: RRL outperforms the competitive approaches, has low complexity close to the simple decision trees, and is rational for its main technical contributions.
Revised: RRL outperforms the competitive approaches, has low complexity close to the simple decision trees, and is rational for its main technical contributions.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Although Deep Neural Networks (DNNs) have achieved impressive results in various machine learning tasks (Goodfellow et al., 2016), rule-based models, beneﬁting from their transparent inner structures and good model expressivity, still play an important role in domains demanding high model interpretability, such as medicine, ﬁnance, and politics (Doshi-Velez & Kim, 2017).
Revised: Although Deep Neural Networks (DNNs) have achieved impressive results in various machine learning tasks (Goodfellow et al., 2016), rule-based models, beneﬁting from their transparent inner structures and good model expressivity, still play an important role in domains demanding high model interpretability, such as medicine, ﬁnance, and politics (Doshi-Velez & Kim, 2017).

Original: In practice, rule-based models can easily provide explanations for users to earn their trust and help protect their rights (Molnar, 2019; Lipton, 2016).
Revised: In practice, rule-based models can easily provide explanations for users to earn their trust and help protect their rights (Molnar, 2019; Lipton, 2016).

Original: By analyzing the learned rules, practitioners can understand the decision mechanism of models, and use their knowledge to improve or debug the models (Chu et al., 2018).
Revised: By analyzing the learned rules, practitioners can understand the decision mechanism of models, and use their knowledge to improve or debug the models (Chu et al., 2018).

Original: Moreover, even if post-hoc methods can provide interpretations for DNNs, the interpretations from rule-based models are more faithful and speciﬁc (Murdoch et al., 2019).
Revised: Moreover, even if post-hoc methods can provide interpretations for DNNs, the interpretations from rule-based models are more faithful and speciﬁc (Murdoch et al., 2019).

Original: However, conventional rule-based models are hard to optimize, especially on large data sets, due to their discrete parameters and structures, which limits their application scope.
Revised: However, conventional rule-based models are hard to optimize, especially on large data sets, due to their discrete parameters and structures, which limits their application scope.

Original: To take advantage of rule-based models in more scenarios, we urgently need to improve their scalability.
Revised: To take advantage of rule-based models in more scenarios, we urgently need to improve their scalability.

Original: Studies in recent years provide some solutions to improve conventional rule-based models in different aspects.
Revised: Studies in recent years provide some solutions to improve conventional rule-based models in different aspects.

Original: Ensemble methods and soft/fuzzy rules are proposed to improve the performance and scalability of rule-based models but at the cost of model interpretability (Ke et al., 2017; Breiman, 2001; Irsoy et al., 2012).
Revised: Ensemble methods and soft/fuzzy rules are proposed to improve the performance and scalability of rule-based models but at the cost of model interpretability (Ke et al., 2017; Breiman, 2001; Irsoy et al., 2012).

Original: Bayesian framework is also leveraged to more reasonably restrict and adjust the structures of rule-based models (Letham et al., 2015; Wang et al., 2017; Yang et al., 2017).
Revised: Bayesian framework is also leveraged to more reasonably restrict and adjust the structures of rule-based models (Letham et al., 2015; Wang et al., 2017; Yang et al., 2017).

Original: However, due to the non-differentiable model structure, they have to use methods like MCMC or
Revised: However, due to the non-differentiable model structure, they have to use methods like MCMC or

Original: Simulated Annealing, which could be time-consuming for large models.
Revised: Simulated Annealing, which could be time-consuming for large models.

Original: Another way to improve rule-based models is to let a high-performance but complex model (e.g., DNN) teach a rule-based model (Frosst & Hinton (2017);
Revised: Another way to improve rule-based models is to let a high-performance but complex model (e.g., DNN) teach a rule-based model (Frosst & Hinton (2017);

Original: Ribeiro et al.
Revised: Ribeiro et al.

Original: However, to learn from the complex model, it requires soft rules, or the ﬁdelity of the student model is not guaranteed.
Revised: However, to learn from the complex model, it requires soft rules, or the ﬁdelity of the student model is not guaranteed.

Original: Wang et al.
Revised: Wang et al.

Original: (2020) try to extract hierarchical rule sets from a tailored neural network.
Revised: (2020) try to extract hierarchical rule sets from a tailored neural network.

Original: Although the extracted rules could behave differently from the neural network when the network is large, combined with binarized networks (Courbariaux et al., 2015), it inspires us that we can search for the discrete solution of rule-based models in a continuous space and leverage optimization methods like gradient descent.
Revised: Although the extracted rules could behave differently from the neural network when the network is large, combined with binarized networks (Courbariaux et al., 2015), it inspires us that we can search for the discrete solution of rule-based models in a continuous space and leverage optimization methods like gradient descent.

Original: In this paper, we propose a novel rule-based model, named Rule-based Representation Learner (RRL) (see Figure 1a), which owns three key technical contributions: (i) To achieve model transparency , RRL is formulated as a hierarchical model, with layers supporting both conjunction and disjunction operations.
Revised: In this paper, we propose a novel rule-based model, named Rule-based Representation Learner (RRL) (see Figure 1a), which owns three key technical contributions: (i) To achieve model transparency , RRL is formulated as a hierarchical model, with layers supporting both conjunction and disjunction operations.

Original: This paves the way for automatically learning interpretable non-fuzzy rules for data representation and classiﬁcation.
Revised: This paves the way for automatically learning interpretable non-fuzzy rules for data representation and classiﬁcation.

Original: (ii) To facilitate training effectiveness , RRL exploits a novel gradient-based discrete model training method, Gradient Grafting, that directly optimizes the discrete model and uses the gradient information at both continuous and discrete points to suit more scenarios.
Revised: (ii) To facilitate training effectiveness , RRL exploits a novel gradient-based discrete model training method, Gradient Grafting, that directly optimizes the discrete model and uses the gradient information at both continuous and discrete points to suit more scenarios.

Original: (iii) To ensure data scalability , RRL utilizes improved logical activation functions to handle high-dimensional features.
Revised: (iii) To ensure data scalability , RRL utilizes improved logical activation functions to handle highdimensional features.

Original: By further combining the improved logical activation functions with a tailored feature binarization layer, it realizes the continuous feature discretization in an end-to-end manner.
Revised: By further combining the improved logical activation functions with a tailored feature binarization layer, it realizes the continuous feature discretization in an end-to-end manner.

Original: We conduct experiments on 9 small data sets and 4 large data sets to validate the advantages of our model over other representative classiﬁcation models.
Revised: We conduct experiments on 9 small data sets and 4 large data sets to validate the advantages of our model over other representative classiﬁcation models.

Original: The beneﬁts of the model’s key components are also veriﬁed by experiments.
Revised: The beneﬁts of the model’s key components are also veriﬁed by experiments.

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

Original: Rule-based Models .
Revised: Rule-based Models .

Original: Decision tree, rule list, and rule set are the widely used structures in rulebased models.
Revised: Decision tree, rule list, and rule set are the widely used structures in rulebased models.

Original: For their discrete parameters and non-differentiable structures, we have to train them by employing various heuristic methods (Quinlan, 1993; Breiman, 2017; Cohen, 1995) which may not ﬁnd the globally best solution or a solution with close performance.
Revised: For their discrete parameters and non-differentiable structures, we have to train them by employing various heuristic methods (Quinlan, 1993; Breiman, 2017; Cohen, 1995) which may not ﬁnd the globally best solution or a solution with close performance.

Original: Alternatively, train them with search algorithms (Wang et al., 2017; Angelino et al., 2017), which could take too much time on large data sets.
Revised: Alternatively, train them with search algorithms (Wang et al., 2017; Angelino et al., 2017), which could take too much time on large data sets.

Original: In recent studies, Bayesian frameworks are leveraged to restrict and adjust model structure more reasonably (Letham et al., 2015; Wang et al., 2017; Yang et al., 2017).
Revised: In recent studies, Bayesian frameworks are leveraged to restrict and adjust model structure more reasonably (Letham et al., 2015; Wang et al., 2017; Yang et al., 2017).

Original: Lakkaraju et al.
Revised: Lakkaraju et al.

Original: (2016) learn independent if-then rules with smooth local search.
Revised: (2016) learn independent if-then rules with smooth local search.

Original: Using algorithmic bounds and efﬁcient data structures, Angelino et al.
Revised: Using algorithmic bounds and efﬁcient data structures, Angelino et al.

Original: (2017) try to accelerate the learning of certiﬁably optimal rule lists.
Revised: (2017) try to accelerate the learning of certiﬁably optimal rule lists.

Original: However, except heuristic methods, most existing rule-based models need frequent itemsets mining and/or long-time searching, which limits their applications.
Revised: However, except heuristic methods, most existing rule-based models need frequent itemsets mining and/or long-time searching, which limits their applications.

Original: Moreover, it is hard for these rule-based models to get comparable performance with complex models like Random Forest.
Revised: Moreover, it is hard for these rule-based models to get comparable performance with complex models like Random Forest.

Original: Ensemble models like Random Forest (Breiman, 2001) and Gradient Boosted Decision Trees (Ke et al., 2017), have better performance than the single rule-based model.
Revised: Ensemble models like Random Forest (Breiman, 2001) and Gradient Boosted Decision Trees (Chen & Guestrin, 2016; Ke et al., 2017), have better performance than the single rule-based model.

Original: However, for the decision is made by hundreds of models, ensemble models are commonly not considered as interpretable models (Hara & Hayashi, 2016).
Revised: However, for the decision is made by hundreds of models, ensemble models are commonly not considered as interpretable models (Hara & Hayashi, 2016).

Original: Soft or fuzzy rules are also used to improve model performance (Irsoy et al., 2012; Ishibuchi & Yamamoto, 2005), but non-discrete rules are much harder to understand than discrete ones.
Revised: Soft or fuzzy rules are also used to improve model performance (Irsoy et al., 2012; Ishibuchi & Yamamoto, 2005), but non-discrete rules are much harder to understand than discrete ones.

Revised: Deep Neural Decision Tree (Yang et al., 2018) is a tree model realized by neural networks with the help of soft binning function and Kronecker product.

Revised: However, due to the use of Kronecker product, it is not scalable with respect to the number of features.

Original: Other studies try to teach the rule-based model by a complex model, e.g., DNN, or extract rule-based models from complex models (Frosst & Hinton, 2017; Ribeiro et al., 2016; Wang et al., 2020).
Revised: Other studies try to teach the rule-based model by a complex model, e.g., DNN, or extract rule-based models from complex models (Frosst & Hinton, 2017; Ribeiro et al., 2016; Wang et al., 2020).

Original: However, the ﬁdelity of the student model or extracted model is not guaranteed.
Revised: However, the ﬁdelity of the student model or extracted model is not guaranteed.

Original: Gradient-based Discrete Model Training .
Revised: Gradient-based Discrete Model Training .

Original: The gradient-based discrete model training methods are mainly proposed to train binary or quantized neural networks for network compression and acceleration.
Revised: The gradient-based discrete model training methods are mainly proposed to train binary or quantized neural networks for network compression and acceleration.

Original: Courbariaux et al.
Revised: Courbariaux et al.

Original: (2015; 2016) propose to use Straight-Through Estimator (STE) for binary neural network training and achieve empirical success.
Revised: (2015; 2016) propose to use Straight-Through Estimator (STE) for binary neural network training and achieve empirical success.

Original: However, STE requires gradient information at discrete points, which limits its applications.
Revised: However, STE requires gradient information at discrete points, which limits its applications.

Original: ProxQuant (Bai et al., 2018) formulates quantized network training as a regularized learning problem and optimizes it via the prox-gradient method.
Revised: ProxQuant (Bai et al., 2018) formulates quantized network training as a regularized learning problem and optimizes it via the prox-gradient method.

Original: ProxQuant can use gradients at non-discrete points, but cannot directly optimize for the discrete model.
Revised: ProxQuant can use gradients at non-discrete points, but cannot directly optimize for the discrete model.

Original: The Random Binarization (RB) method (Wang et al., 2020) trains a neural network with random binarization for its weights to ensure the discrete and continuous model behave samely.
Revised: The Random Binarization (RB) method (Wang et al., 2020) trains a neural network with random binarization for its weights to ensure the discrete and continuous model behave samely.

Original: However, when the model is large, the differences between the discrete and continuous model are inevitable.
Revised: However, when the model is large, the differences between the discrete and continuous model are inevitable.

Revised: Gumbel-Softmax estimator (Jang et al., 2016) generates a categorical distribution with a differentiable sample.

Revised: However, we can hardly deal with a large number of variables, e.g., the weights of binary networks, using the Gumbel-Softmax estimator for it is a biased estimator.

Original: Our method, i.e., Gradient Grafting, is different from all the aforementioned works in using gradient information of both discrete and continuous models in each backpropagation.
Revised: Our method, i.e., Gradient Grafting, is different from all the aforementioned works in using gradient information of both discrete and continuous models in each backpropagation.

Original: Notation Description. Let D = { ( X 1 , y 1 ) , . . .
Revised: [Figure]

Original: , ( X N , y N ) } denote the training data set with N instances, where X i is the observed feature vector of the i -th instance with the j -th entry as X i,j , and y i is the corresponding class label, i ∈ { 1 , . . . , N } . Each feature value can be either discrete or continuous. All the classes take discrete values, and the number of class labels is denoted by
Revised: B

Original: [Figure]
Revised: [Figure]

Original: B i

Original: Logical Layer u ( l − 1)u ( l − 1)u ( l − 1)u ( l − 1)r ( l ) r ( l ) s ( l )1 s ( l )
Revised: Logical Layer u ( l − 1)u ( l − 1)u ( l − 1)u ( l − 1)r ( l ) r ( l ) s ( l )1 s ( l )

Original: Corresponding Rules !
Revised: Corresponding Rules !

Original: r ( l )

Revised: r ( l )

Original: =
Revised: =

Original: u
Revised: u

Original: ( l − 1)r ( l )1 = u ( l − 1)∧ u
Revised: ( l − 1)r ( l )1 = u ( l − 1)∧ u

Original: ( l − 1)s ( l )1 = u ( l − 1)s ( l )

Revised: ( l − 1)s ( l )1 = u ( l − 1)s ( l )

Original: = u ( l − 1)∨ u ( l − 1)∨ u ( l − 1)
Revised: = u ( l − 1)∨ u ( l − 1)∨ u ( l − 1)

Original: A Discrete Logical Layer Example:
Revised: A Discrete Logical Layer Example:

Original: [Figure]
Revised: [Figure]

Original: θ
Revised: θ

Original: Loss ( · )
Revised: Loss [Figure]

Original: ForwardBackward ˆ y ¯
Revised: ForwardBackward ˆ y ¯

Original: y
Revised: y

Original: [Figure]
Revised: [Figure]

Revised:  R ULE - BASED R EPRESENTATION L EARNER

Revised: Notation Description.

Revised: Let D

Revised: = { ( X 1 , y 1 ) , . . .

Revised: , ( X N , y N ) } denote the training data set with N instances, where X i is the observed feature vector of the i -th instance with the j -th entry as X i,j , and y i is the corresponding class label, i ∈ { 1 , . . .

Revised: , N } .

Revised: Each feature value can be either discrete or continuous.

Revised: All the classes take discrete values, and the number of class labels is denoted by

Original: M .
Revised: M .

Original: We use one-hot encoding to represent all discrete features as binary features.
Revised: We use one-hot encoding to represent all discrete features as binary features.

Original: Let C i ∈
Revised: Let C i ∈

Original: R m and B i ∈ { 0 , 1 } b denote the continuous feature vector and the binary feature vector of the i -th instance respectively.
Revised: R m and B i ∈ { 0 , 1 } b denote the continuous feature vector and the binary feature vector of the i -th instance respectively.

Original: Therefore, X i =
Revised: Therefore, X i =

Original: C i ⊕
Revised: C i ⊕

Original: B i , where ⊕ represents the operator that concatenates two vectors.
Revised: B i , where ⊕ represents the operator that concatenates two vectors.

Original: Throughout this paper, we use 1 (True) and 0 (False) to represent the two states of a
Revised: Throughout this paper, we use 1 (True) and 0 (False) to represent the two states of a

Original: Boolean variable.
Revised: Boolean variable.

Original: Thus each dimension of a binary feature vector corresponds to a Boolean variable.
Revised: Thus each dimension of a binary feature vector corresponds to a Boolean variable.

Original: Overall Structure.
Revised: Overall Structure.

Original: A Rule-based Representation Learner (RRL), denoted by F , is a hierarchical model consisting of three different types of layers.
Revised: A Rule-based Representation Learner (RRL), denoted by F , is a hierarchical model consisting of three different types of layers.

Original: Each layer in RRL not only contains a speciﬁc number of nodes, but also has trainable edges connected with its previous layer.
Revised: Each layer in RRL not only contains a speciﬁc number of nodes, but also has trainable edges connected with its previous layer.

Original: Let U ( l ) denote the l -th layer of RRL, u ( l ) j indicate the j -th node in the layer, and n l represent the corresponding number of nodes, l ∈ { 0 , . . .
Revised: Let U ( l ) denote the l -th layer of RRL, u ( l ) j indicate the j -th node in the layer, and n l represent the corresponding number of nodes, l ∈ { 0 , . . .

Original: , L } .
Revised: , L } .

Original: The output of the l -th layer is a vector containing the values of all the nodes in the layer.
Revised: The output of the l -th layer is a vector containing the values of all the nodes in the layer.

Original: For ease of expression, we denote this vector by u ( l ) .
Revised: For ease of expression, we denote this vector by u ( l ) .

Original: There are only one binarization layer, i.e., U (0) , and one linear layer, i.e., U ( L ) , in RRL, but the number of middle layers, i.e., logical layers, can be ﬂexibly adjusted according to the speciﬁc situation.
Revised: There are only one binarization layer, i.e., U (0) , and one linear layer, i.e., U ( L ) , in RRL, but the number of middle layers, i.e., logical layers, can be ﬂexibly adjusted according to the speciﬁc situation.

Original: The logical layers mainly aim to learn the non-linear part of the data while the linear layer aims to learn the linear part.
Revised: The logical layers mainly aim to learn the non-linear part of the data while the linear layer aims to learn the linear part.

Original: One example of RRL is shown in Figure 1a.
Revised: One example of RRL is shown in Figure 1a.

Original: When we input the i -th instance to RRL, the binarization layer will ﬁrst binarize the continuous feature vector C i into a new binary vector ¯ C i .
Revised: When we input the i -th instance to RRL, the binarization layer will ﬁrst binarize the continuous feature vector C i into a new binary vector ¯ C i .

Original: Then, ¯ C i and B i are concatenated together as u (0) and inputted to the ﬁrst logical layer.
Revised: Then, ¯ C i and B i are concatenated together as u (0) and inputted to the ﬁrst logical layer.

Original: The logical layers are designed to automatically learn data representations using logical rules, and the stacked logical layers can learn rules in more complex forms.
Revised: The logical layers are designed to automatically learn data representations using logical rules, and the stacked logical layers can learn rules in more complex forms.

Original: After going through all the logical layers, the output of the last logical layer can be considered as the new feature vector to represent the instance, wherein each feature corresponds to one rule formulated by the original features.
Revised: After going through all the logical layers, the output of the last logical layer can be considered as the new feature vector to represent the instance, wherein each feature corresponds to one rule formulated by the original features.

Original: As such, the whole RRL is composed of a feature learner and a linear classiﬁer (linear layer).
Revised: As such, the whole RRL is composed of a feature learner and a linear classiﬁer (linear layer).

Original: Moreover, the skip connections in RRL can skip unnecessary logical layers.
Revised: Moreover, the skip connections in RRL can skip unnecessary logical layers.

Original: In what follows, the details of these components will be elaborated.
Revised: In what follows, the details of these components will be elaborated.

Original: 3. L OGICAL L AYER
Revised: 3. L OGICAL L AYER

Original: Considering the binarization layer needs the help of its following logical layer to binarize features in an end-to-end way, we introduce logical layers ﬁrst.
Revised: Considering the binarization layer needs the help of its following logical layer to binarize features in an end-to-end way, we introduce logical layers ﬁrst.

Original: As mentioned above, logical layers can learn data representations using logical rules automatically.
Revised: As mentioned above, logical layers can learn data representations using logical rules automatically.

Original: To achieve this, logical layers are designed to have a discrete version and a continuous version.
Revised: To achieve this, logical layers are designed to have a discrete version and a continuous version.

Original: The discrete version is used for training, testing and interpretation while the continuous version is only used for training.
Revised: The discrete version is used for training, testing and interpretation while the continuous version is only used for training.

Original: It is worth noting that the discrete RRL indicates the parameter weights of logical layers take discrete values (i.e., 0 or 1).
Revised: It is worth noting that the discrete RRL indicates the parameter weights of logical layers take discrete values (i.e., 0 or 1).

Original: Discrete Version.
Revised: Discrete Version.

Original: One logical layer consists of one conjunction layer and one disjunction layer.
Revised: One logical layer consists of one conjunction layer and one disjunction layer.

Original: In discrete version, let R ( l ) and S ( l ) denote the conjunction and disjunction layer of U ( l ) ( l ∈ { 1 , 2 , . . .
Revised: In discrete version, let R ( l ) and S ( l ) denote the conjunction and disjunction layer of U ( l ) ( l ∈ { 1 , 2 , . . .

Original: , L − 1 } ) respectively.
Revised: , L − 1 } ) respectively.

Original: We denote the i -th node in R ( l ) by r ( l ) i , and the i -th node in S ( l ) by s ( l ) i .
Revised: We denote the i -th node in R ( l ) by r ( l ) i , and the i -th node in S ( l ) by s ( l ) i .

Original: Speciﬁcally speaking, node r ( l ) i corresponds to the conjunction of nodes in the previous layer connected with r ( l ) i , while node s ( l ) i corresponds to the disjunction of nodes in previous layer connected with s ( l ) i .
Revised: Speciﬁcally speaking, node r ( l ) i corresponds to the conjunction of nodes in the previous layer connected with r ( l ) i , while node s ( l ) i corresponds to the disjunction of nodes in previous layer connected with s ( l ) i .

Original: Formally, the two types of nodes are deﬁned as follows:
Revised: Formally, the two types of nodes are deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: where W ( l, 0) denote the adjacency matrix of the conjunction layer R ( l ) and the previous layer
Revised: where W ( l, 0) denote the adjacency matrix of the conjunction layer R ( l ) and the previous layer

Original: U ( l − 1) , and W ( l, 0) i,j ∈ { 0 , [Equation] [Equation] l
Revised: U ( l − 1) , and W ( l, 0) i,j ∈ { 0 , 1 } .

Original: [Equation] i [Equation] j = 1 indicates there exists an edge connecting r ( l ) i to u ( l − 1)
Revised: W ( l, 0) i,j = 1 indicates there exists an edge connecting r ( l ) i to u ( l − 1)

Original: j , otherwise W ( l, 0) i,j = 0 .
Revised: j , otherwise W ( l, 0) i,j = 0 .

Original: Similarly, W ( l, 1) is the adjacency matrix of the disjunction layer S ( l ) and
Revised: Similarly, W ( l, 1) is the adjacency matrix of the disjunction layer S ( l ) and

Original: U ( l − 1) .
Revised: U ( l − 1) .

Original: Similar to neural networks, we regard these adjacency matrices as the weight matrices of logical layers.
Revised: Similar to neural networks, we regard these adjacency matrices as the weight matrices of logical layers.

Original: u ( l ) =
Revised: u ( l ) =

Original: r ( l ) ⊕ s ( l ) , where r ( l ) and s ( l ) are the outputs of R ( l ) and S ( l ) respectively.
Revised: r ( l ) ⊕ s ( l ) , where r ( l ) and s ( l ) are the outputs of R ( l ) and S ( l ) respectively.

Original: The function of the logical layer is similar to the notion “level” in Wang et al.
Revised: The function of the logical layer is similar to the notion “level” in Wang et al.

Original: However, one level in that work, which actually consists of two layers, can only represent rules in Disjunctive
Revised: However, one level in that work, which actually consists of two layers, can only represent rules in Disjunctive

Original: Normal Form (DNF), while two logical layers can represent rules in DNF and Conjunctive Normal
Revised: Normal Form (DNF), while two logical layers can represent rules in DNF and Conjunctive Normal

Original: Form (CNF) at the same time.
Revised: Form (CNF) at the same time.

Original: Connecting nodes in R ( l ) with nodes in S ( l − 1) , we get rules in CNF, while connecting nodes in S ( l ) with nodes in R ( l − 1) , we get rules in DNF.
Revised: Connecting nodes in R ( l ) with nodes in S ( l − 1) , we get rules in CNF, while connecting nodes in S ( l ) with nodes in R ( l − 1) , we get rules in DNF.

Original: The ﬂexibility of logical layer is quite important.
Revised: The ﬂexibility of logical layer is quite important.

Original: For instance, the length of CNF rule ( a 1 ∨ a 2 ) ∧ · · · ∧ ( a 2 n − 1 ∨ a 2 n ) is 2 n , but the length of its corresponding DNF rule (a∧ a 3 · · · ∧ a 2 n − 1 ) ∨ · · · ∨ ( a 2 ∧ a 4 · · · ∧ a 2 n ) is n · 2 n , which means layers that only represent DNF can hardly learn this CNF rule.
Revised: For instance, the length of CNF rule ( a 1 ∨ a 2 ) ∧ · · · ∧ ( a 2 n − 1 ∨ a 2 n ) is 2 n , but the length of its corresponding DNF rule ( a [Equation] is n · 2 n , which means layers that only represent DNF can hardly learn this CNF rule.

Original: Continuous Version.
Revised: Continuous Version.

Original: Although the discrete logical layers have good interpretability, they are hard to train for their discrete parameters and non-differentiable structures.
Revised: Although the discrete logical layers have good interpretability, they are hard to train for their discrete parameters and non-differentiable structures.

Original: Inspired by the training process of binary neural networks that searches the discrete solution in a continuous space, we extend the discrete logical layer to a continuous version.
Revised: Inspired by the training process of binary neural networks that searches the discrete solution in a continuous space, we extend the discrete logical layer to a continuous version.

Revised: The continuous version is differentiable, and when we discretize the parameters of a continuous logical layer, we can obtain its corresponding discrete logical layer.

Original: Let ˆ U ( l ) denote the continuous logical layer, and ˆ R ( l ) and ˆ S ( l ) denote the continuous conjunction and disjunction layer respectively, l ∈ { 1 , 2 , . . .
Revised: Let ˆ U ( l ) denote the continuous logical layer, and ˆ R ( l ) and ˆ S ( l ) denote the continuous conjunction and disjunction layer respectively, l ∈ { 1 , 2 , . . .

Original: , L − 1 } .
Revised: , L − 1 } .

Original: Let ˆ W ( l, 0) and ˆ W ( l, 1) denote the weight matrices of ˆ R ( l ) and ˆ S ( l ) respectively.
Revised: Let ˆ W ( l, 0) and ˆ W ( l, 1) denote the weight matrices of ˆ R ( l ) and ˆ S ( l ) respectively.

Original: ˆ W ( l, 0) i,j , ˆ W ( l, 1) i,j ∈ [0 , 1] .
Revised: ˆ W ( l, 0) i,j , ˆ W ( l, 1) i,j ∈ [0 , 1] .

Original: To make the whole Equationdifferentiable, we leverage the logical activation functions proposed by Payani & Fekri (2019):Conj ( [Equation] [Equation]
Revised: To make the whole Equationdifferentiable, we leverage the logical activation functions proposed by Payani & Fekri (2019):

Original: (cid:89)

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: where F c ( h, w ) = 1 − w (1 − h ) and F d ( h, w ) = h · w .
Revised: where F c ( h, w ) = 1 − w (1 − h ) and F d ( h, w ) = h · w .

Original: In Equation 2, if h and W i are both binary vectors, then Conj ( h , W i ) =
Revised: In Equation 2, if h and W i are both binary vectors, then Conj ( h , W i ) =

Original: (cid:86) W i,j =1 h j and Disj ( h , W i ) = (cid:87) W
Revised: (cid:86) W i,j =1 h j and Disj ( h , W i ) = (cid:87) W

Original: i,j =1 h j .
Revised: i,j =1 h j .

Original: F c ( h, w ) and F d ( h, w ) decide how much h j would affect the operation according to W i,j .
Revised: F c ( h, w ) and F d ( h, w ) decide how much h j would affect the operation according to W i,j .

Original: If W i,j = 0 , h j would have no effect on the operation.
Revised: If W i,j = 0 , h j would have no effect on the operation.

Original: After using continuous weights and logical activation functions, the nodes in ˆ R ( l ) and ˆ S ( l ) are deﬁned as follows:
Revised: After using continuous weights and logical activation functions, the nodes in ˆ R ( l ) and ˆ S ( l ) are deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: Now the whole logical layer is differentiable and can be trained by gradient descent.
Revised: Now the whole logical layer is differentiable and can be trained by gradient descent.

Original: However, above logical activation functions suffer from the serious vanishing gradient problem.
Revised: However, above logical activation functions suffer from the serious vanishing gradient problem.

Original: The main reason can be found by analyzing the partial derivative of each node w.r.t.
Revised: The main reason can be found by analyzing the partial derivative of each node w.r.t.

Original: its directly connected weights and w.r.t.
Revised: its directly connected weights and w.r.t.

Original: its directly connected nodes as follows:
Revised: its directly connected nodes as follows:

Original: [Equation]
Revised: [Equation]

Original: Due to ˆ u ( l − 1) k and ˆ W ( l, 0) i,k are in the range [0 , 1] , the values of F c ( · ) in Equation 4 are in the range [0 , 1] as well.
Revised: Due to ˆ u ( l − 1) k and ˆ W ( l, 0) i,k are in the range [0 , 1] , the values of F c ( · ) in Equation 4 are in the range [0 , 1] as well.

Original: If n l − 1 is large and most of the values of F c ( · ) are not 1, then the derivative is close to 0 because of the multiplications (See Appendix A for the analysis of ˆ s ( l ) i ).
Revised: If n l − 1 is large and most of the values of F c ( · ) are not 1, then the derivative is close to 0 because of the multiplications (See Appendix A for the analysis of ˆ s ( l ) i ).

Original: Wang et al.
Revised: Wang et al.

Original: (2020) try to use weight initialization to make F c ( · ) close to 1 at the beginning.
Revised: (2020) try to use weight initialization to make F c ( · ) close to 1 at the beginning.

Original: However, when dealing with hundreds of features, the vanishing gradient problem is still inevitable.
Revised: However, when dealing with hundreds of features, the vanishing gradient problem is still inevitable.

Original: We found that using the multiplications to simulate the logical operations in Equation 2 is the main reason for vanishing gradients and propose improved logical activation functions.
Revised: We found that using the multiplications to simulate the logical operations in Equation 2 is the main reason for vanishing gradients and propose improved logical activation functions.

Original: One straightforward thought is to convert multiplications into additions using logarithm, e.g., log( (cid:81) nj =1 F c ( h j , W i,j ))
Revised: One straightforward thought is to convert multiplications into additions using logarithm, e.g., log( (cid:81) nj =1 F c ( h j , W i,j ))

Original: = (cid:80) nj =1 log( F c ( h j , W i,j )) .
Revised: = (cid:80) nj =1 log( F c ( h j , W i,j )) .

Original: However, after taking the logarithm, the logical activation functions in Equation 2 cannot keep the characteristics of logical operations any more, and the ranges of Conj ( · ) and Disj ( · ) are not [0 , 1] .
Revised: However, after taking the logarithm, the logical activation functions in Equation 2 cannot keep the characteristics of logical operations any more, and the ranges of Conj ( · ) and Disj ( · ) are not [0 , 1] .

Original: To deal with this problem, we need a projection function to ﬁx it.
Revised: To deal with this problem, we need a projection function to ﬁx it.

Original: Apparently, the inverse function of log( x ) , i.e., e x , is not suitable.
Revised: Apparently, the inverse function of log( x ) , i.e., e x , is not suitable.

Original: For the projection function g , three conditions must be satisﬁed: (i) g (0) =
Revised: For the projection function g , three conditions must be satisﬁed: (i) g (0) =

Original: e 0 = 1 .
Revised: e 0 = 1 .

Original: (ii) lim 
Revised: (ii) lim x →−∞ g ( x ) =

Original: [Equation]
Revised: lim x →−∞ e x = 0 .

Original: (iii)
Revised: (iii)

Original: lim x →−∞ e x g ( x ) = 0 .
Revised: lim x →−∞ e x g ( x ) = 0 .

Original: Condition (i) and (ii) aim to keep the range and tendency of logical activation functions.
Revised: Condition (i) and (ii) aim to keep the range and tendency of logical activation functions.

Original: Condition (iii) aims to lower the speed of approaching zero when x → −∞ .
Revised: Condition (iii) aims to lower the speed of approaching zero when x → −∞ .

Original: In this work, we choose g ( x ) = − 1 − 1+ x as the projection function, and the improvement of logical activation functions can be summarized as the function
Revised: In this work, we choose g ( x ) = − 1 − 1+ x as the projection function, and the improvement of logical activation functions can be summarized as the function

Original: P ( v ) = − 1 − 1+log( v ) .
Revised: P ( v ) = − 1 − 1+log( v ) .

Original: The improved conjunction function Conj + and disjunction function Disj + are given by:
Revised: The improved conjunction function Conj + and disjunction function Disj + are given by:

Original: [Equation]
Revised: [Equation]

Original: where (cid:15) is a small constant, e.g., 10 − 10 .
Revised: where (cid:15) is a small constant, e.g., 10 − 10 .

Original: The improved logical activation functions can avoid the vanishing gradient problem in most scenarios and are much more scalable than the originals.
Revised: The improved logical activation functions can avoid the vanishing gradient problem in most scenarios and are much more scalable than the originals.

Original: Moreover, considering that d P ( v ) dv = P 2 ( v ) v , when n in Equation 5 is extremely large, d P ( v ) dv may be very close to 0 due to P 2 ( v ) .
Revised: Moreover, considering that d P ( v ) dv = P 2 ( v ) v , when n in Equation 5 is extremely large, d P ( v ) dv may be very close to 0 due to P 2 ( v ) .

Original: One trick to deal with it is replacing P 2 ( v ) v with P ( P 2 ( v )) v for P can lower the speed of approaching 0 while keeping the value range and tendency.
Revised: One trick to deal with it is replacing P 2 ( v ) v with P ( P 2 ( v )) v for P can lower the speed of approaching 0 while keeping the value range and tendency.

Original: 3. B INARIZATION L AYER
Revised: 3. B INARIZATION L AYER

Original: Binarization layer is mainly used to divide the continuous feature values into several bins.
Revised: Binarization layer is mainly used to divide the continuous feature values into several bins.

Original: By combining one binarization layer and one logical layer, we can automatically choose the appropriate bins for feature discretization (binarization), i.e., binarizing features in an end-to-end way.
Revised: By combining one binarization layer and one logical layer, we can automatically choose the appropriate bins for feature discretization (binarization), i.e., binarizing features in an end-to-end way.

Original: For the j -th continuous feature, there are k lower bounds ( L j, 1 , . . .
Revised: For the j -th continuous feature, there are k lower bounds ( L j, 1 , . . .

Original: , L j,k ) and k upper bounds (
Revised: , L j,k ) and k upper bounds (

Original: H j, 1 , . . . , H j,k ).
Revised: H j, 1 , . . . , H j,k ).

Original: All these bounds are randomly selected (e.g., from uniform distribution) in the value range of the j -th continuous feature, and these bounds are not trainable.
Revised: All these bounds are randomly selected (e.g., from uniform distribution) in the value range of the j -th continuous feature, and these bounds are not trainable.

Original: When inputting one continuous feature vector c , the binarization layer will check if c j satisﬁes the bounds and get the following binary vector:
Revised: When inputting one continuous feature vector c , the binarization layer will check if c j satisﬁes the bounds and get the following binary vector:

Original: [Equation]
Revised: [Equation]

Original: where q ( x ) = 1 x > 0 .{+
+}
Revised: where q ( x ) = 1 x > {+
+}

Original: If we input the i -th instance, i.e., c = C i , then ¯ C i
Revised: If we input the i -th instance, i.e., c = C i , then ¯ C i

Original: = Q 1 ⊕ Q 2 · · · ⊕ Q m and u (0) =
Revised: = Q 1 ⊕ Q 2 · · · ⊕ Q m and u (0) =

Original: ¯ C i ⊕ Bi .
Revised: ¯ C i ⊕ Bi .

Original: After inputting u (0) to the logical layer U (1) , the edge connections between
Revised: After inputting u (0) to the logical layer U (1) , the edge connections between

Original: U (1) and U (0) indicate the choice of bounds (bins).
Revised: U (1) and U (0) indicate the choice of bounds (bins).

Original: For example, if r (1) i is connected to the nodes corresponding to q ( c j −L j, 1 ) and q ( H j, 2 − c j ) , then r (1) i contains the bin ( L j, 1 < c j ) ∧ ( c j < H j, 2 ) .
Revised: For example, if r (1) i is connected to the nodes corresponding to q ( c j −L j, 1 ) and q ( H j, 2 − c j ) , then r (1) i contains the bin ( L j, 1 < c j ) ∧ ( c j < H j, 2 ) .

Original: If we replace r (1) i with s (1) i in the example, we can get ( L j, 1 < c j ) ∨ ( c j < H j, 2 ) .
Revised: If we replace r (1) i with s (1) i in the example, we can get ( L j, 1 < c j ) ∨ ( c j < H j, 2 ) .

Original: It should be noted that, in practice, if L j, 1 ≥ H j, 2 , then r (1) i = 0 , and if L j, 1 < H j, 2 , then s (1) i = 1 .
Revised: It should be noted that, in practice, if L j, 1 ≥ H j, 2 , then r (1) i = 0 , and if L j, 1 < H j, 2 , then s (1) i = 1 .

Original: When using the continuous version, the weights of logical layers are trainable, which means we can choose bounds in an end-to-end way.
Revised: When using the continuous version, the weights of logical layers are trainable, which means we can choose bounds in an end-to-end way.

Original: For the number of bounds is 2 k times of features, which could be large, only logical layers with improved logical activation functions are capable of choosing the bounds.
Revised: For the number of bounds is 2 k times of features, which could be large, only logical layers with improved logical activation functions are capable of choosing the bounds.

Original: 3. G RADIENT G RAFTING
Revised: 3. G RADIENT G RAFTING

Original: Although RRL can be differentiable with the continuous logical layers, it is challenging to search for a discrete solution in a continuous space.
Revised: Although RRL can be differentiable with the continuous logical layers, it is challenging to search for a discrete solution in a continuous space.

Original: To tackle this problem, one commonly used method is
Revised: To tackle this problem, one commonly used method is

Original: Straight-Through Estimator (STE) (Courbariaux et al.
Revised: Straight-Through Estimator (STE) (Courbariaux et al.

Original: The STE method needs gradients at discrete points to update the parameters.
Revised: The STE method needs gradients at discrete points to update the parameters.

Original: However, the gradients of RRL at discrete points have no useful information in most cases (See Appendix B).
Revised: However, the gradients of RRL at discrete points have no useful information in most cases (See Appendix B).

Original: Therefore STE is not suitable for RRL.
Revised: Therefore STE is not suitable for RRL.

Original: Other methods like ProxQuant (Bai et al.
Revised: Other methods like ProxQuant (Bai et al.

Original: and Random Binarization (Wang et al.
Revised: and Random Binarization (Wang et al.

Original: (2020)) cannot directly optimize for the discrete model and be scalable at the same time.
Revised: (2020)) cannot directly optimize for the discrete model and be scalable at the same time.

Original: Inspired by plant grafting, we propose a new training method, called Gradient Grafting, that can effectively train RRL.
Revised: Inspired by plant grafting, we propose a new training method, called Gradient Grafting, that can effectively train RRL.

Original: In stem grafting, one plant is selected for its roots, i.e., rootstock, and the other plant is selected for its stems, i.e., scion.
Revised: In stem grafting, one plant is selected for its roots, i.e., rootstock, and the other plant is selected for its stems, i.e., scion.

Original: By grafting, we obtain a new plant with the advantages of both two plants.
Revised: By grafting, we obtain a new plant with the advantages of both two plants.

Original: In Gradient Grafting, the gradient of the loss function w.r.t.
Revised: In Gradient Grafting, the gradient of the loss function w.r.t.

Original: the output of discrete model is the scion, and the gradient of the output of continuous model w.r.t.
Revised: the output of discrete model is the scion, and the gradient of the output of continuous model w.r.t.

Original: the parameters of continuous model is the rootstock.
Revised: the parameters of continuous model is the rootstock.

Original: Speciﬁcally, let θ denote the parameter vector and θ t denote the parameter vector at step t .
Revised: Speciﬁcally, let θ denote the parameter vector and θ t denote the parameter vector at step t .

Original: q ( x ) = 1 x > 0 .
Revised: q ( x ) = 1 x > 0 .

Original: 5 is the binarization function that binarizes each dimension of x with 0.5 as the threshold.
Revised: 5 is the binarization function that binarizes each dimension of x with 0.5 as the threshold.

Original: Let ˆ y and ¯ y denote the output of the continuous model ˆ F and discrete model F respectively, then ˆ y
Revised: Let ˆ y and ¯ y denote the output of the continuous model ˆ F and discrete model F respectively, then ˆ y

Original: = ˆ F ( θ t , X ) , ¯ y = F ( q ( θ t ) , X ) .
Revised: = ˆ F ( θ t , X ) , ¯ y = F ( q ( θ t ) , X ) .

Original: The parameters update with Gradient
Revised: The parameters update with Gradient

Original: Grafting is formulated by:
Revised: Grafting is formulated by:

Original: [Equation]
Revised: [Equation]

Original:  where η is the learning rate and L ( · ) is the loss function.
Revised: ∂θ t , (7) where η is the learning rate and L ( · ) is the loss function.

Original: One simpliﬁed computation graph of
Revised: One simpliﬁed computation graph of

Original: Gradient Grafting is shown in Figure 1b for intuitive understanding.
Revised: Gradient Grafting is shown in Figure 1b for intuitive understanding.

Original: Gradient Grafting can directly optimize the loss of discrete models and use the gradient information at both continuous and discrete points, which overcomes the problems occurring in RRL training when using other gradient-based discrete model training methods.
Revised: Gradient Grafting can directly optimize the loss of discrete models and use the gradient information at both continuous and discrete points, which overcomes the problems occurring in RRL training when using other gradient-based discrete model training methods.

Original: 3. M ODEL I NTERPRETATION
Revised: 3. M ODEL I NTERPRETATION

Original: After training with Gradient Grafting, the discrete RRL can be used for testing and interpretation.
Revised: After training with Gradient Grafting, the discrete RRL can be used for testing and interpretation.

Original: RRL is easy to interpret for we can simply consider it as a feature learner and a linear classiﬁer.
Revised: RRL is easy to interpret for we can simply consider it as a feature learner and a linear classiﬁer.

Original: The binarization layer and logical layers are the feature learner, and they use logical rules to build and describe the new features.
Revised: The binarization layer and logical layers are the feature learner, and they use logical rules to build and describe the new features.

Original: The linear classiﬁer, i.e., the linear layer, makes decisions based on the new features.
Revised: The linear classiﬁer, i.e., the linear layer, makes decisions based on the new features.

Original: We can ﬁrst ﬁnd the important new features by the weights of the linear layer, then understand each new feature by analyzing its corresponding rules.
Revised: We can ﬁrst ﬁnd the important new features by the weights of the linear layer, then understand each new feature by analyzing its corresponding rules.

Original: The L1/L2 regularization can be used during training to search for an RRL with shorter rules.
Revised: The L1/L2 regularization can be used during training to search for an RRL with shorter rules.

Original: The dead nodes detection and redundant rules elimination proposed by Wang et al.
Revised: The dead nodes detection and redundant rules elimination proposed by Wang et al.

Original: (2020) can also be used for better interpretability.
Revised: (2020) can also be used for better interpretability.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In this section, we conduct experiments to evaluate the proposed model and answer the following questions: (i) How is the classiﬁcation performance of RRL compared to the competitive approaches?
Revised: In this section, we conduct experiments to evaluate the proposed model and answer the following questions: (i) How is the classiﬁcation performance of RRL compared to the competitive approaches?

Original: (ii) How is the model complexity of RRL?
Revised: (ii) How is the model complexity of RRL?

Original: (iii) How is the convergence of Gradient
Revised: (iii) How is the convergence of Gradient

Original: Grafting compared to other gradient-based discrete model training methods?
Revised: Grafting compared to other gradient-based discrete model training methods?

Original: 4. D ATASET D ESCRIPTION AND E XPERIMENTAL S ETTINGS
Revised: 4. D ATASET D ESCRIPTION AND E XPERIMENTAL S ETTINGS

Original: We took 9 small and 4 large public datasets to conduct our experiments, all of which are often used to test classiﬁcation performance and model interpretability (Dua & Graff, 2017; Xiao et al., 2017;
Revised: We took 9 small and 4 large public datasets to conduct our experiments, all of which are often used to test classiﬁcation performance and model interpretability (Dua & Graff, 2017; Xiao et al., 2017;

Original: Anguita et al., 2013; Moro et al., 2016).
Revised: Anguita et al., 2013; Moro et al., 2016).

Original: Appendix C summarizes the statistics of these 13 datasets.
Revised: Appendix C summarizes the statistics of these 13 datasets.

Original: Together they show the data diversity, ranging from 178 to 102944 instances, from 2 to 26 classes, and from 4 to 4714 original features.
Revised: Together they show the data diversity, ranging from 178 to 102944 instances, from 2 to 26 classes, and from [Table] 57.16 facebook 90.27 80. 86.85 fashion 89.01 80.

Original:  We adopt the F1 score (Macro) as the classiﬁcation performance metric since some of the data sets are imbalanced, i.e., the numbers of different classes are quite different.
Revised: AvgRank 2. We adopt the F1 score (Macro) as the classiﬁcation performance metric since some of the data sets are imbalanced, i.e., the numbers of different classes are quite different.

Original: We adopt 5-fold crossvalidation to evaluate the classiﬁcation performance more fairly.
Revised: We adopt 5-fold crossvalidation to evaluate the classiﬁcation performance more fairly.

Original: When parameter tuning is required, 95% of the training set is used for training and 5% for validation.
Revised: When parameter tuning is required, 95% of the training set is used for training and 5% for validation.

Original: Considering that reused structures exist in rule-based models, e.g., one branch in Decision Tree can correspond to several rules, we use the total number of edges instead of the total length of all rules as the metric of model complexity for rule-based models.
Revised: Considering that reused structures exist in rule-based models, e.g., one branch in Decision Tree can correspond to several rules, we use the total number of edges instead of the total length of all rules as the metric of model complexity for rule-based models.

Original: 4. C LASSIFICATION P ERFORMANCE
Revised: 4. C LASSIFICATION P ERFORMANCE

Original: We compare the classiﬁcation F1 score (Macro) of RRL, C4.5 (Quinlan, 1993), CART (Breiman, 2017), Scalable Bayesian Rule Lists (SBRL)(Yang et al., 2017), Concept Rule Sets (CRS) (Wang et al., 2020), Regression ( ) (Kleinbaum et al., 2002)
Revised: We compare the classiﬁcation F1 score (Macro) of RRL, C4.5 (Quinlan, 1993), CART (Breiman, 2017), Scalable Bayesian Rule Lists (SBRL)

Original: Neural Network

Original: [Table]

Original: 57.16 facebook 90.27 80.

Original: 86.85 fashion 89.01 80.

Original: Average 86.55 80. (PLNN) (Chu et al., 2018), Support Vector Machines (SVM) (Scholkopf & Smola, 2001) with linear, RBF or Ploy kernel, Gradient Boosted Decision Tree (Ke et al., 2017) with 100 estimators (GBDT e =100 ), and Random Forest (Breiman, 2001) with 10 estimators (RF e =10 ) and 100 estimators (RF e =100 ).
Revised: (Yang et al., 2017), Concept Rule Sets (CRS) (Wang et al., 2020), Logistic Regression (LR) (Kleinbaum et al., 2002), Piecewise Linear Neural Network (PLNN) (Chu et al., 2018), Support Vector Machines (SVM) (Scholkopf & Smola, 2001) with linear, RBF or Ploy kernel, Gradient Boosted Decision Tree (Ke et al., 2017) with 100 estimators (GBDT e =100 ), and Random Forest (Breiman, 2001) with 10 estimators (RF e =10 ) and 100 estimators (RF e =100 ).

Original: C4.5, CART, SBRL and CRS are all rule-based models, and LR is a linear model.
Revised: C4.5, CART, SBRL and CRS are all rule-based models, and LR is a linear model.

Original: These ﬁve models are considered as interpretable models.
Revised: These ﬁve models are considered as interpretable models.

Original: PLNN is a Multilayer Perceptron (MLP) that adopts piecewise linear activation functions, e.g., ReLU (Nair & Hinton, 2010).
Revised: PLNN is a Multilayer Perceptron (MLP) that adopts piecewise linear activation functions, e.g., ReLU (Nair & Hinton, 2010).

Original: PLNN, SVM,
Revised: PLNN, SVM,

Original: GBDT and Random Forest are considered as complex models.
Revised: GBDT and Random Forest are considered as complex models.

Original: The results are shown in Table 1, and the ﬁrst 9 data sets are small data sets while the last 4 are large data sets.
Revised: The results are shown in Table 1, and the ﬁrst 9 data sets are small data sets while the last 4 are large data sets.

Original: We can observe that RRL performs well on almost all the data sets and gets the best results on 6 data sets.
Revised: We can observe that RRL performs well on almost all the data sets and gets the best results on 6 data sets.

Original: RRL outperforms other interpretable models and only two complex models, i.e., GBDT e =100 and RF e =100 , have comparable results.
Revised: RRL outperforms other interpretable models and only two complex models, i.e., GBDT e =100 and RF e =100 , have comparable results.

Original: Compared RRL with LR and other rulebased models, we can see RRL can ﬁt both linear and non-linear data well.
Revised: Compared RRL with LR and other rulebased models, we can see RRL can ﬁt both linear and non-linear data well.

Original: CRS performs well on small data sets but fails on large datasets due to the limitation of its logical activation functions and training method.
Revised: CRS performs well on small data sets but fails on large datasets due to the limitation of its logical activation functions and training method.

Original: Good results on both small and large data sets verify RRL has good scalability.
Revised: Good results on both small and large data sets verify RRL has good scalability.

Original: Moreover, SBRL and CRS do not perform well on continuous feature data sets like letRecog and magic04 for they need preprocessing to discretize continuous features, which may bring bias to the data sets.
Revised: Moreover, SBRL and CRS do not perform well on continuous feature data sets like letRecog and magic04 for they need preprocessing to discretize continuous features, which may bring bias to the data sets.

Original: On the contrary, RRL overcomes this problem by discretizing features end-to-end.
Revised: On the contrary, RRL overcomes this problem by discretizing features end-to-end.

Original: 4. M ODEL C OMPLEXITY
Revised: 4. M ODEL C OMPLEXITY

Original: Interpretable models need to keep low model complexity while ensuring high accuracy.
Revised: Interpretable models need to keep low model complexity while ensuring high accuracy.

Original: To show the relationships between accuracy and model complexity, we draw scatter plots of F1 score against log(#edges) for rule-based models in Figure 2 (see Appendix E for results on other data sets).
Revised: To show the relationships between accuracy and model complexity, we draw scatter plots of F1 score against log(#edges) for rule-based models in Figure 2 (see Appendix G for results on other data sets).

Original: The value in CART(0.03) denotes the complexity parameter used for Minimal Cost-Complexity Pruning (Breiman, 2017), and a higher value corresponds to a simpler tree.
Revised: The value in CART(0.03) denotes the complexity parameter used for Minimal Cost-Complexity Pruning (Breiman, 2017), and a higher value corresponds to a simpler tree.

Original: We can observe that RRL is much simpler than random forests, and its complexity is close to CRS and decision trees without pruning.
Revised: We can observe that RRL is much simpler than random forests, and its complexity is close to CRS and decision trees without pruning.

Original: Meanwhile, RRL has higher F1 scores than models with close complexity.
Revised: Meanwhile, RRL has higher F1 scores than models with close complexity.

Original: It also indicates that RRL can make better use of rules than models using heuristic and ensemble methods.
Revised: It also indicates that RRL can make better use of rules than models using heuristic and ensemble methods

Original:  4. A BLATION S TUDY
Revised: . 4. A BLATION S TUDY

Original: Training Method for Discrete Model.
Revised: Training Method for Discrete Model.

Original: To show the effectiveness of Gradient Grafting for training
Revised: To show the effectiveness of Gradient Grafting for training

Original: RRL, we compare it with other representative gradient-based discrete model training methods, i.e.,
Revised: RRL, we compare it with other representative gradient-based discrete model training methods, i.e.,

Original: [Figure]

Original: STE (Courbariaux et al., 2015; 2016), ProxQuant (Bai et al., 2018) and RB (Wang et al., 2020), by training RRL with the same structure.
Revised: STE (Courbariaux et al., 2015; 2016), ProxQuant (Bai et al., 2018) and RB (Wang et al., 2020), by training RRL with the same structure.

Original: Hyperparameters are set to be the same for each method except exclusive hyperparameters, e.g., random binarization rate for RB, are ﬁne-tuned.
Revised: Hyperparameters are set to be the same for each method except exclusive hyperparameters, e.g., random binarization rate for RB, are ﬁne-tuned.

Original: In Figure 3, we can see that the convergence of Gradient Grafting is faster and stabler than other methods on all data sets.
Revised: In Figure 3, we can see that the convergence of Gradient Grafting is faster and stabler than other methods on all data sets.

Original: As we mentioned in Section 3.3, RRL has little useful gradient information at discrete points, thus STE cannot converge.
Revised: As we mentioned in Section 3.3, RRL has little useful gradient information at discrete points, thus STE cannot converge.

Original: Due to the difference between discrete and continuous RRL,
Revised: Due to the difference between discrete and continuous RRL,

Original: ProxQuant and RB cannot converge well as well.
Revised: ProxQuant and RB cannot converge well as well.

Original: Improved Logical Activation Functions.
Revised: Improved Logical Activation Functions.

Original: We also compare RRL trained by Gradient Grafting with or without improved logical activation functions.
Revised: We also compare RRL trained by Gradient Grafting with or without improved logical activation functions.

Original: The results are also shown in Figure 3, and
Revised: The results are also shown in Figure 3, and

Original: GradGrafting(NI) represents RRL using original logical activation functions instead of improved logical activation functions.
Revised: GradGrafting(NI) represents RRL using original logical activation functions instead of improved logical activation functions.

Original: We can observe that the original activation functions work well on small data sets but fail on the large data set activity while the improved activation functions work well on all data sets, which means the improved logical activation functions make RRL more scalable.
Revised: We can observe that the original activation functions work well on small data sets but fail on the large data set activity while the improved activation functions work well on all data sets, which means the improved logical activation functions make RRL more scalable.

Original: It should be noted that GradGrafting(NI) works well on the large data set facebook , the reason is facebook is a very sparse data set, and the number of 1 in each binary feature vector is less than(See Appendix A for detailed analyses).
Revised: It should be noted that GradGrafting(NI) works well on the large data set facebook , the reason is facebook is a very sparse data set, and the number of 1 in each binary feature vector is less than(See Appendix A for detailed analyses).

Original: 4. C ASE S TUDY
Revised: 4. C ASE S TUDY

Original: We show how the learned rules look like by case studies.
Revised: We show how the learned rules look like by case studies.

Original: In Figure 4, we show the learned rules, with high weights, of RRL trained on bank-marketing data set (See Appendix D for fashion data set).
Revised: In Figure 4, we show the learned rules, with high weights, of RRL trained on bank-marketing data set (See Appendix F for the distribution of weights and see Appendix E for fashion data set).

Original: These rules are used to predict if the client will subscribe a term deposit by telesales.
Revised: These rules are used to predict if the client will subscribe a term deposit by telesales.

Original: Different types of features are marked in different colors, e.g., purple for previous behaviours of the bank.
Revised: Different types of features are marked in different colors, e.g., purple for previous behaviours of the bank.

Original: We can clearly see that middle-aged married persons with low balance are more likely to subscribe a deposit, and the previous behaviour of the bank would also affect the client.
Revised: We can clearly see that middle-aged married persons with low balance are more likely to subscribe a deposit, and the previous behaviour of the bank would also affect the client.

Original: Then the bank can change their strategies according to these rules.
Revised: Then the bank can change their strategies according to these rules.

Revised: [Figure]

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We propose a new scalable classiﬁer, named Rule-based Representation Learner (RRL), that can automatically learn interpretable rules for data representation and classiﬁcation.
Revised: We propose a new scalable classiﬁer, named Rule-based Representation Learner (RRL), that can automatically learn interpretable rules for data representation and classiﬁcation.

Original: For the particularity of RRL, we propose a new gradient-based discrete model training method, i.e., Gradient Grafting, that directly optimizes the discrete model.
Revised: For the particularity of RRL, we propose a new gradient-based discrete model training method, i.e., Gradient Grafting, that directly optimizes the discrete model.

Original: We also propose an improved design of logical activation functions to increase the scalability of RRL and make RRL capable of discretizing the continuous features end-to-end.
Revised: We also propose an improved design of logical activation functions to increase the scalability of RRL and make RRL capable of discretizing the continuous features end-to-end.

Original: Our experimental results show that RRL enjoys both high classiﬁcation performance and low model complexity on data sets with different scales.
Revised: Our experimental results show that RRL enjoys both high classiﬁcation performance and low model complexity on data sets with different scales.

Original: A V ANISHING G RADIENT P ROBLEM
Revised: A V ANISHING G RADIENT P ROBLEM

Original: The partial derivative of each node in ˆ S ( l ) w.r.t.
Revised: The partial derivative of each node in ˆ S ( l ) w.r.t.

Original: its directly connected weights and w.r.t.
Revised: its directly connected weights and w.r.t.

Original: its directly connected nodes are given by:
Revised: its directly connected nodes are given by:

Original: [Equation]
Revised: [Equation]

Original: Similar to the analysis of Equation 4, due to ˆ u ( l − 1) k and ˆ W ( l, 1) i,k are in the range [0 , 1] , the values of (1 − F d ( · )) in Equation 8 and 9 are in the range [0 , 1] as well.
Revised: Similar to the analysis of Equation 4, due to ˆ u ( l − 1) k and ˆ W ( l, 1) i,k are in the range [0 , 1] , the values of (1 − F d ( · )) in Equation 8 and 9 are in the range [0 , 1] as well.

Original: If n l − 1 is large and most of the values of (1 − F d ( · )) are not 1, then the derivative is close to 0 because of the multiplications.
Revised: If n l − 1 is large and most of the values of (1 − F d ( · )) are not 1, then the derivative is close to 0 because of the multiplications.

Original: Therefore, both the conjunction function and the disjunction function suffer from vanishing gradient problem.
Revised: Therefore, both the conjunction function and the disjunction function suffer from vanishing gradient problem.

Original: If the large data set is very sparse and the number of 1 in each binary feature vector (for RRL the binary feature vector is u (0) ) is less than about one hundred, there will be no vanishing gradient problem for nodes in ˆ S (1) .
Revised: If the large data set is very sparse and the number of 1 in each binary feature vector (for RRL the binary feature vector is u (0) ) is less than about one hundred, there will be no vanishing gradient problem for nodes in ˆ S (1) .

Original: The reason is when the number of 1 in each feature vector is less than about one hundred, in Equation 8 and 9, most of the values of (1 − F d ( · )) are 1, and only less than one hundred values of (1 − F d ( · )) are not 1, then the result of the multiplication is not very close to 0.
Revised: The reason is when the number of 1 in each feature vector is less than about one hundred, in Equation 8 and 9, most of the values of (1 − F d ( · )) are 1, and only less than one hundred values of (1 − F d ( · )) are not 1, then the result of the multiplication is not very close to 0.

Original: The facebook data set is an example of this case.
Revised: The facebook data set is an example of this case.

Original: However, if the number of 1 in each binary feature vector is more than about one hundred, the vanishing gradient problem comes again.
Revised: However, if the number of 1 in each binary feature vector is more than about one hundred, the vanishing gradient problem comes again.

Original: B G RADIENTS AT D ISCRETE P OINTS
Revised: B G RADIENTS AT D ISCRETE P OINTS

Original: The gradients of RRL with original logical activation functions at discrete points can be obtained by
Revised: The gradients of RRL with original logical activation functions at discrete points can be obtained by

Original: Equation 4, 8 and 9.
Revised: Equation 4, 8 and 9.

Original: Take Equation 8 as an example, discrete points mean all the weights of logical layers are 0 or 1, which also means the values of all the nodes in ˆ U ( l ) are 0 or 1, l ∈ { 0 , 1 , . . .
Revised: Take Equation 8 as an example, discrete points mean all the weights of logical layers are 0 or 1, which also means the values of all the nodes in ˆ U ( l ) are 0 or 1, l ∈ { 0 , 1 , . . .

Original: , L − 1 } .
Revised: , L − 1 } .

Original: Hence, in Equation 8, ˆ u ( l − 1) j , (1 − F d ( · )) ∈ { 0 , 1 } , and the whole equation is actually multiplications of several 0 and several 1.
Revised: Hence, in Equation 8, ˆ u ( l − 1) j , (1 − F d ( · )) ∈ { 0 , 1 } , and the whole equation is actually multiplications of several 0 and several 1.

Original: Only when ˆ u ( l − 1) j and (1 − F d ( · )) are all 1, the derivative in Equation 8 is 1, otherwise, the derivative is 0.
Revised: Only when ˆ u ( l − 1) j and (1 − F d ( · )) are all 1, the derivative in Equation 8 is 1, otherwise, the derivative is 0.

Original: Therefore, the gradients at discrete points have no useful information in most cases.
Revised: Therefore, the gradients at discrete points have no useful information in most cases.

Original: The analyses of Equation 4 and 9 are similar.
Revised: The analyses of Equation 4 and 9 are similar.

Original: To analyze the gradients of RRL with improved logical activation functions at discrete points, we ﬁrst calculate the partial derivative of each node w.r.t.
Revised: To analyze the gradients of RRL with improved logical activation functions at discrete points, we ﬁrst calculate the partial derivative of each node w.r.t.

Original: its directly connected weights and w.r.t.
Revised: its directly connected weights and w.r.t.

Original: its directly connected nodes:
Revised: its directly connected nodes:

Original: [Equation]
Revised: [Equation]

Original: Take Equation 10 for example, when all the weights of logical layers are 0 or 1, the ˆ r ( l ) i , F c ( · ) + (cid:15) and (ˆ u ( l − 1) j − 1) are all very close to 0 or 1 as well.
Revised: Take Equation 10 for example, when all the weights of logical layers are 0 or 1, the ˆ r ( l ) i , F c ( · ) + (cid:15) and (ˆ u ( l − 1) j − 1) are all very close to 0 or 1 as well.

Original: For the initialized weights are randomly selected, ˆ r ( l ) i is close to 0 in most cases.
Revised: For the initialized weights are randomly selected, ˆ r ( l ) i is close to 0 in most cases.

Original: Hence, the derivative in Equation 10 is close to 0 in most cases, and the analyses of Equation 11, 12 and 13 are similar.
Revised: Hence, the derivative in Equation 10 is close to 0 in most cases, and the analyses of Equation 11, 12 and 13 are similar.

Original: Therefore, the gradients at discrete points have little useful information.
Revised: Therefore, the gradients at discrete points have little useful information.

Original: C D ATAS ETS P ROPERTIES
Revised: C D ATA

Revised: [Equation]

Original: Table 2 summarizes the statistics of 13 datasets that we used in the experiments.
Revised: Table 2 summarizes the statistics of 13 datasets that we used in the experiments.

Original: The ﬁrst 9 data sets are small data sets while the last 4 are large data sets.
Revised: The ﬁrst 9 data sets are small data sets while the last 4 are large data sets.

Original: Discrete or continuous feature type indicates features in that data set are all discrete or all continuous.
Revised: Discrete or continuous feature type indicates features in that data set are all discrete or all continuous.

Original: The mixed feature type indicates the data set has both discrete and continuous features.
Revised: The mixed feature type indicates the data set has both discrete and continuous features.

Original: The density is the averaged ratio of the number ofin each binary feature vector after one-hot encoding.
Revised: The density is the averaged ratio of the number ofin each binary feature vector after one-hot encoding.

Original: [Table]
Revised: [Table]

Original: D C ASE S TUDY
Revised: D C OMPUTATION T IME

Original: Although RRL is not designed for image classiﬁcation tasks, due to its high scalability, it can still provide intuition by visualizations.
Revised: The computation time of RRL is similar to neural networks like Multilayer Perceptrons (MLP) for their computations are quite similar.

Original: Take fashion dataset for example
Revised: The training time of RRL on all the datasets (400 epochs on the small datasets and 100 epochs on the large datasets) with one GeForce RTX 2080 Ti is shown in Table 3. We can see that the training time of RRL is acceptable on all the datasets, which also veriﬁes the good scalability of RRL. [Table]

Original: [Table]
Revised: [Table]

Revised: E C ASE S TUDY

Revised: Although RRL is not designed for image classiﬁcation tasks, due to its high scalability, it can still provide intuition by visualizations.

Original:  for each class, we combine the ﬁrst ten rules, ordered by linear layer weights, for feature (pixel) visualization.
Revised: Take fashion dataset for example, for each class, we combine the ﬁrst ten rules, ordered by linear layer weights, for feature (pixel) visualization.

Original: In Figure 5, a black/white pixel indicates the combined rule asks for a color close to black/white here in the original input image [Table] and the grey pixel means no requirement in the rule.
Revised: In Figure 5, a black/white pixel indicates the combined rule asks for a color close to black/white here in the original input image, and the grey pixel means no requirement in the rule.

Original: According to these ﬁgures, we can see how RRL classiﬁes the images, e.g., distinguish T-shirt from Pullover by sleeves.
Revised: According to these ﬁgures, we can see how RRL classiﬁes the images, e.g., distinguish T-shirt from Pullover by sleeves.

Original: E M ODEL C OMPLEXITY
Revised: F D ISTRIBUTION OF W EIGHTS IN THE L INEAR L AYER

Original:  Figure 6 shows the scatter plots of F1 score against log(#edges) for rule-based models trained on the other 10 data sets.
Revised: [Table] Figure 6 shows the scatter plots of F1 score against log(#edges) for rule-based models trained on the other 10 data sets.

Original: The value in CART(0.03) denotes the complexity parameter used for Minimal
Revised: The value in CART(0.03) denotes the complexity parameter used for Minimal

Original: Cost-Complexity Pruning (Breiman, 2017), and a higher value corresponds to a simpler tree.
Revised: Cost-Complexity Pruning (Breiman, 2017), and a higher value corresponds to a simpler tree.

Original: On these 10 data sets, we can still observe that RRL is much simpler than random forests, and its complexity is close to CRS and decision trees without pruning.
Revised: On these 10 data sets, we can still observe that RRL is much simpler than random forests, and its complexity is close to CRS and decision trees without pruning.

Original: Meanwhile, RRL has higher F scores than models with close complexity in most cases.
Revised: Meanwhile, RRL has higher F scores than models with close complexity in most cases.

Revised: H A VERAGE R ULE L ENGTH

Revised: The average length of rules in RRL trained on different datasets is shown in Table 5.

Revised: We can observe that except the facebook and fashion datasets, the average length of rules is less than 13 (most are less than 7), which means understanding one rule is easy and understanding the rules one by one in the order of weights is feasible.

Revised: The average length of rules of RRL trained on the facebook and fashion datasets is large for facebook and fashion are actually two unstructured datasets, e.g., the fashion dataset is an image classiﬁcation dataset.

Revised: [Table]