2602.13583

# Differentiable Rule Induction from Raw Sequence Inputs > Corresponding author. ## Abstract Rule learning-based models are widely used in highly interpretable scenarios due to their transparent structures. Inductive logic programming (ILP), a form of machine learning, induces rules from facts while maintaining interpretability. Differentiable ILP models enhance this process by leveraging neural networks to improve robustness and scalability. However, most differentiable ILP methods rely on symbolic datasets, facing challenges when learning directly from raw data. Specifically, they struggle with explicit label leakage: The inability to map continuous inputs to symbolic variables without explicit supervision of input feature labels. In this work, we address this issue by integrating a self-supervised differentiable clustering model with a novel differentiable ILP model, enabling rule learning from raw data without explicit label leakage. The learned rules effectively describe raw data through its features. We demonstrate that our method intuitively and precisely learns generalized rules from time series and image data. ## 1 Introduction The deep learning models have obtained impressive performances on tabular classification, time series forecasting, image recognition, etc. While in highly trustworthy scenarios such as health care, finance, and policy-making process (Doshi-Velez and Kim, 2017), lacking explanations for decision-making prevents the applications of these complex deep learning models. However, the rule-learning models have interpretability intrinsically to explain the classification process. Inductive logic programming (ILP) is a form of logic-based machine learning that aims to learn logic programs for generalization and interpretability from training examples and background knowledge (Cropper et al., 2022). Traditional ILP methods design deterministic algorithms to induce rules from symbolic data to more generalized formal symbolic first-order languages (Quinlan, 1990; Blockeel and De Raedt, 1998). However, these symbolic ILP methods face robustness and scalability problems when learning from large-scale and ambiguous datasets (Evans et al., 2021; Hocquette et al., 2024). With the sake of robustness of neural networks, the neuro-symbolic ILP by combining neural networks and ILP methods can learn from noisy data (Evans and Grefenstette, 2018; Manhaeve et al., 2018; Gao et al., 2022a) and can be applied to large-scale datasets (Yang et al., 2017; Gao et al., 2024; Phua and Inoue, 2024). However, existing neuro-symbolic ILP methods are mainly learned from discrete symbolic data or fuzzy symbolic data that the likelihoods are generated from a pre-trained neural network module (Evans et al., 2021; Shindo et al., 2023). Learning logic programs from raw data is prevented because of the explicit label leakage problem, which is common in neuro-symbolic research (Topan et al., 2021): The leakage happens by introducing labels of ground objects for inducing rules (Evans and Grefenstette, 2018; Shindo et al., 2023). In fact, generating rules to describe objects in raw data without label information is necessary, especially when some objects are easily overlooked or lack labels yet are important for describing the data. In this study, we introduce Neural Rule Learner (NeurRL), a framework designed to learn logic programs directly from raw sequences, such as time series and flattened image data. Unlike prior approaches prone to explicit label leakage, where input feature labels are extracted using pre-trained supervised neural networks and then processed with differentiable ILP methods to induce rules trained with input labels, our method bypasses the need for supervised pre-trained networks to generate symbolic labels. Instead, we leverage a pre-trained clustering model in an unsupervised manner to discretize data into distinct features. Subsequently, a differentiable clustering module and a differentiable rule-learning module are jointly trained under supervision using raw input labels. This enables the discovery of rules that describe input classes based on feature distributions within the inputs. As a result, the model achieves efficient training in a fully differentiable pipeline while avoiding the explicit label leakage issue. The contributions of this study include: (1) We formally define the ILP learning task from raw inputs based on the interpretation transition setting of ILP. (2) We design a fully differentiable framework for learning symbolic rules from raw sequences, including a novel interpretable rule-learning module with multiple dense layers. (3) We validate the model’s effectiveness and interpretability on various time series and image datasets. ## 2 Related work Inductive logic programming (ILP), introduced by Muggleton and Feng (1990); Muggleton and De Raedt (1994), learns logic programs from symbolic positive and negative examples with background knowledge. Inoue et al. (2014) proposed learning from interpretation transitions, and Phua and Inoue (2021) applied ILP to Boolean networks. Manhaeve et al. (2018); Evans and Grefenstette (2018) adapted neural networks for differentiable and robust ILP, while Gao et al. (2022b) introduced a neural network-based ILP model for learning from interpretation transitions. This model was later extended for scalable learning from knowledge graphs (Gao et al., 2022a; 2024). Similarly, Liu et al. (2024) proposed a deep neural network for inducing mathematical functions. In our work, we present a novel neural network-based model for learning logic programs from raw numeric inputs. In the raw input domain, Evans and Grefenstette (2018) proposed $\partial$ ILP to learn rules from symbolic relational data, using a pre-trained neural network to map raw input data to symbolic labels. Unlike $\partial$ ILP, which enforces a strong language bias by predefining logic templates and limiting the number of atoms, NeurRL uses only predicate types as language bias. Similarly, Evans et al. (2021) used pre-trained networks to map sensory data to disjunctive sequences, followed by binary neural networks to learn rules. Shindo et al. (2023) introduced $\alpha$ ILP, leveraging object recognition models to convert images into symbolic atoms and employing top- $k$ searches to pre-generate clauses, with neural networks optimizing clause weights. Our approach avoids pre-trained large-scale neural networks for mapping raw inputs to symbolic representations. Instead, we propose a fully differentiable framework to learn rules from raw sequences. Additionally, unlike the memory-intensive rule candidate generation required by $\partial$ ILP and $\alpha$ ILP, NeurRL eliminates this step, enhancing scalability. Adapting autoencoder and clustering methods in the neuro-symbolic domain shows promise. Sansone and Manhaeve (2023) applies conventional clustering on input embeddings for deductive logic programming tasks. Misino et al. (2022) and Zhan et al. (2022) use autoencoders and embeddings to calculate probabilities for predefined symbols to complete deductive logic programming and program synthesis tasks. In our approach, we use an autoencoder to learn representations for sub-areas of raw inputs, followed by a differentiable clustering method to assign ground atoms to similar patterns. The differentiable rule-learning module then searches for rule embeddings with these atoms in a bottom-up manner (Cropper and Dumancic, 2022). Similarly, DIFFNAPS (Walter et al., 2024) also uses an autoencoder to build hidden features and explain raw inputs. Additionally, BotCL (Wang et al., 2023) uses attention-based features to explain the ground truth class. However, the logical connections between the features used in DIFFNAPS and BotCL to describe the ground truth class are unclear. In contrast, rule-based explainable models like NeurRL use feature conjunctions to describe the ground truth class. Azzolin et al. (2023) use a post-hoc rule-based explainable model to globally explain raw inputs from local explanations. In contrast, our model directly learns rules from raw inputs, and NeurRL’s performance is unaffected by other explainable models. Das et al. (1998) used clustering to split sequence data into subsequences and symbolize them for rule discovery. Our model combines clustering and rule-learning in a fully differentiable framework to discover rules from sequence and image data, with the rule-learning module providing gradient information to prevent cluster collapse (Sansone, 2023), where very different subsequences are assigned to the same clusters. He et al. (2018) viewed similar subsequences, called motifs, as potential rule bodies. Unlike their approach, we do not limit the number of body atoms in a rule. Wang et al. (2019) introduced SSSL, which uses shapelets as body atoms to learn rules and maximize information gain. Our model extends this by using raw data subsequences as rule body atoms and evaluating rule quality with precision and recall, a feature absent in SSSL. ## 3 Preliminaries ### 3.1 Logic Programs and Inductive Logic Programming A first-order language $\mathcal{L}=(D,F,C,V)$ (Lloyd, 1984) consists of predicates $D$ , function symbols $F$ , constants $C$ , and variables $V$ . A term is a constant, variable, or expression $f(t_{1},\dots,t_{n})$ with $f$ as an $n$ -ary function symbol. An atom is a formula $p(t_{1},\dots,t_{n})$ , where $p$ is an $n$ -ary predicate symbol. A ground atom (fact) has no variables. A literal is an atom or its negation; positive literals are atoms, and negative literals are their negations. A clause is a finite disjunction of literals, and a rule (definite clause) is a clause with one positive literal, e.g., $\alpha_{h}\lor\neg\alpha_{1}\lor\neg\alpha_{2}\lor\dots\lor\neg\alpha_{n}$ . A rule $r$ is written as: $\alpha_{h}\leftarrow\alpha_{1},\alpha_{2},\dots,\alpha_{n}$ , where $\alpha_{h}$ is the head ( $\textnormal{head}(r)$ ), and $\{\alpha_{1},\alpha_{2},\dots,\alpha_{n}\}$ is the body ( $\textnormal{body}(r)$ ), with each atom in the body called a body atom. A logic program $P$ is a set of rules. In first-order logic, a substitution is a finite set $\{v_{1}/t_{1},v_{2}/t_{2},\dots,v_{n}/t_{n}\}$ , where each $v_{i}$ is a variable, $t_{i}$ is a term distinct from $v_{i}$ , and $v_{1},v_{2},\dots,v_{n}$ are distinct (Lloyd, 1984). A ground substitution has all $t_{i}$ as ground terms. The ground instances of all rules in $P$ are denoted as $\textnormal{ground}(P)$ . The Herbrand base $B_{P}$ of a logic program $P$ is the set of all ground atoms with predicate symbols from $P$ , and an interpretation $I$ is a subset of $B_{P}$ containing the true ground atoms (Lloyd, 1984). Given $I$ , the immediate consequence operator $T_{P}\colon 2^{B_{P}}\to 2^{B_{P}}$ for a definite logic program $P$ is defined as: $T_{P}(I)=\{\text{head}(r)\mid r\in\textnormal{ground}(P),\textnormal{body}(r)\subseteq I\}$ (Apt et al., 1988). A logic program $P$ with $m$ rules sharing the same head atom $\alpha_{h}$ is called a same-head logic program. A same-head logic program with $n$ possible body atoms can be represented as a matrix $\mathbf{M}_{P}\in[0,1]^{m\times n}$ . Each element $a_{kj}$ in $\mathbf{M}_{P}$ is defined as follows (Gao et al., 2022a): If the $k$ -th rule is $\alpha_{h}\leftarrow\alpha_{j_{1}}\land\dots\land\alpha_{j_{p}}$ , then $a_{k{j_{i}}}=l_{i}$ , where $l_{i}\in(0,1)$ and $\sum_{s=1}^{p}l_{s}=1\ (1\leq i\leq p,\ 1<p,\ 1\leq j_{i}\leq n,\ 1\leq k\leq m)$ . If the $k$ -th rule is $\alpha_{h}\leftarrow\alpha_{j}$ , then $a_{kj}=1$ . Otherwise, $a_{kj}=0$ . Each row of $\mathbf{M}_{P}$ represents a rule in $P$ , and each column represents a body atom. An interpretation vector $\mathbf{v}_{I}\in\{0,1\}^{n}$ corresponds to an interpretation $I$ , where $\mathbf{v}_{I}[i]=1$ if the $i$ -th ground atom is true in $I$ , and $\mathbf{v}_{I}[i]=0$ otherwise. Given a logic program with $m$ rules and $n$ atoms, along with an interpretation vector $\mathbf{v}_{I}$ , the function $D_{P}:\{0,1\}^{n}\to\{0,1\}^{m}$ (Gao et al., 2024) calculate the Boolean value for the head atom of each rule in $P$ . It is defined as:: $$ \displaystyle D_{P}(\mathbf{v}_{I})=\theta(\mathbf{M}_{P}\mathbf{v}_{I}), \tag{1} $$ where the function $\theta$ is a threshold function: $\theta(x)=1$ if $x\geq 1$ , otherwise $\theta(x)=0$ . For a same-head logic program, the Boolean value of the head atom $v(\alpha_{h})$ is computed as $v(\alpha_{h})=\bigvee_{i=1}^{m}D_{P}(\mathbf{v}_{I})[i]$ . Additionally, Gao et al. (2024) replaces $\theta(x)$ with a differentiable threshold function and use fuzzy disjunction $\tilde{\bigvee}_{i=1}^{m}\mathbf{x}[i]=1-\prod_{i=1}^{m}\mathbf{x}[i]$ to calculate the Boolean value of the head atom in a same-head logic program with neural networks. Inductive logic programming (ILP) aims to induce logic programs from training examples and background knowledge (Muggleton et al., 2012). ILP learning settings include learning from entailments (Evans and Grefenstette, 2018), interpretations (De Raedt and Dehaspe, 1997), proofs (Passerini et al., 2006), and interpretation transitions (Inoue et al., 2014). In this paper, we focus on learning from interpretation transitions: Given a set $E\subseteq 2^{B_{P}}\times 2^{B_{P}}$ of interpretation pairs $(I,J)$ , the goal is to learn a logic program $P$ such that $T_{P}(I)=J$ for all $(I,J)\in E$ . ### 3.2 Sequence data and Differentiable Clustering Method A raw input consists of an instance $(\mathbf{x},\mathbf{y})$ , where $\mathbf{x}\in\mathbb{R}^{T_{1}\times T_{2}\times\dots\times T_{d}}$ represents real-valued observations with $d$ variables, $T_{i}$ indicates the length for $i$ -th variable, and $\mathbf{y}\in\{0,1,\dots,u-1\}$ is the class label, with $u$ classes. A sequence input is a type of raw input where $\mathbf{x}\in\mathbb{R}^{T_{1}}$ is an ordered sequence of real-valued observations (Wang et al., 2019). A subsequence $\mathbf{s}_{i}$ of length $l$ from sequence $\mathbf{x}=(x_{1},x_{2},\dots,x_{T})$ is a contiguous sequence $(x_{i},\dots,x_{i+l-1})$ (Das et al., 1998). All possible subsequence with length $l$ include $\mathbf{s}_{1}$ , …, $\mathbf{s}_{T-l+1}$ . Clustering can be used to discover new categories (Rokach and Maimon, 2005). In the paper, we adapt the differentiable $k$ -means method (Fard et al., 2020) to group raw data $\mathbf{x}\in\mathbf{X}$ . First, an autoencoder $A$ generates embeddings $\mathbf{h}_{\gamma}$ for $\mathbf{x}$ , where $\gamma$ represents the parameters. Then, we set $K$ clusters to discretize all raw data $\mathbf{x}$ . The representation of the $k$ -th cluster is $\mathbf{r}_{k}\in\mathbb{R}^{p}$ , with $p$ as the dimension, and $\mathcal{R}=\{\mathbf{r}_{1},\dots,\mathbf{r}_{K}\}$ as the set of all cluster representations. For any vector $\mathbf{y}\in\mathbb{R}^{p}$ , the function $c_{f}(\mathbf{y};\mathcal{R})$ returns the closest representation based on a fully differentiable distance function $f$ . Then, the differentiable $k$ -means problems are defined as follows: $$ \displaystyle\min_{\mathcal{R},\gamma}\sum_{\mathbf{x}\in\mathbf{X}}f(\mathbf{x},A(\mathbf{x};\gamma))+\lambda\sum_{k=1}^{K}f(\mathbf{h}_{\gamma}(\mathbf{x}),\mathbf{r}_{k})G_{k,f}(\mathbf{h}_{\gamma}(\mathbf{x}),\alpha;\mathcal{R}), \tag{2} $$ where the parameter $\lambda$ regulates the trade-off between seeking good representations for $\mathbf{x}$ and the representations that are useful for clustering. The weight function $G$ is a differentiable minimum function proposed by Jang et al. (2017): $$ \displaystyle G_{k,f}(\mathbf{h}_{\gamma}(\mathbf{x}),\alpha;\mathcal{R})=\frac{e^{-\alpha f(\mathbf{h}_{\gamma}(\mathbf{x}),\mathbf{r}_{k})}}{\sum_{k^{\prime}=1}^{K}e^{-\alpha f(\mathbf{h}_{\gamma}(\mathbf{x}),\mathbf{r}_{k^{\prime}})}}, \tag{3} $$ where $\alpha\in[0,+\infty)$ . A larger value of $\alpha$ causes the approximate minimum function to behave more like a discrete minimum function. Conversely, a smaller $\alpha$ results in a smoother training process We set $\alpha$ to 1000 in the whole experiments.. ## 4 Methods ### 4.1 Problem Statement and formalization In this subsection, we define the learning problem from raw inputs using the interpretation transition setting of ILP and describe the language bias of rules for sequence data. We apply a neuro-symbolic description method from Marconato et al. (2023) to describe a raw input: (i) assume the label $\mathbf{y}$ depends entirely on the state of $K$ symbolic concepts $B=(a_{1},a_{2},\dots,a_{K})$ , which capture high-level aspects of $\mathbf{x}$ , (ii) the concepts $B$ depend intricately on the sub-symbolic input $\mathbf{x}^{\prime}$ and are best extracted using deep learning, (iii) the relationship between $\mathbf{y}$ and $B$ can be specified by prior knowledge $\mathcal{B}$ , requiring reasoning during the forward computing of deep learning models. In this paper, we treat each subset of raw input as a constant and each concept as a ground atom. For example, in sequence data $\mathbf{x}\in\mathbf{X}$ , if a concept increases from the point 0 to 10, the corresponding ground atom is $\texttt{increase}(\mathbf{x}[0:10])$ . We define the body symbolization function $L_{b}$ to convert a continuous sequence $\mathbf{x}$ into discrete symbolic concepts, so that the set of all symbolic concepts $B$ across all raw inputs $\mathbf{X}$ holds $B=L_{b}(\mathbf{X})$ . For binary class raw inputs, we use target atom $h_{t}$ to represents the target class, where $h_{t}$ being true means the instance belongs to the positive class. Then, a head symbolization function $L_{h}$ maps an binary input $\mathbf{x}$ to a set of atoms: if the class of $\mathbf{x}$ is the target class $t$ , then $L_{h}(\mathbf{x})=\{h_{t}\}$ ; otherwise, $L_{h}(\mathbf{x})=\emptyset$ . Hence, a logic program $P$ describing binary class raw inputs consists of rules with the same head atom $h_{t}$ We can transfer multiple class raw inputs to the binary class by setting the class of interest as the target class and the other classes as the negative class.. We define the Herbrand base $B_{P}$ of a logic program as the set of all symbolic concepts $B$ in all raw inputs and the head atom $h_{t}$ . For a raw input $\mathbf{x}$ , $L_{b}(\mathbf{x})$ represents a set of symbolic concepts $I\subseteq B_{P}$ , which can be considered an interpretation. The task of inducing a logic program $P$ from raw inputs based on learning from interpretation transition is defined as follows: **Definition 1 (Learning from Binary Raw Input)** *Given a set of raw binary label inputs $\mathbf{X}$ , learn a same-head logic program $P$ , where $T_{P}(L_{b}(\mathbf{x}))=L_{h}(\mathbf{x})$ holds for all raw inputs $\mathbf{x}\in\mathbf{X}$ .* In the paper, we aim to learn rules to describe the target class with the body consisting of multiple sequence features. Each feature corresponds to a subsequence of the sequence data. Besides, each feature includes the pattern information and region information of the subsequence. Based on the pattern information, we further infer the mean value and tendency information of the subsequence. Using the region predicates, we can apply NeurRL to the dataset, where the temporal relationships between different patterns play a crucial role in distinguishing positive from negative examples. Specifically, we use the following rules to describe the sequence data with the target class: $$ \displaystyle h_{t}\leftarrow pattern_{i_{1}}(X_{j_{1}}),region_{k_{1}}(X_{j_{1}}),\dots,pattern_{i_{n_{1}}}(X_{j_{n_{2}}}),region_{k_{n_{3}}}(X_{j_{n_{2}}}), \tag{4} $$ where the predicate $\texttt{pattern}_{i}$ indicates the $i$ -th pattern in all finite patterns within all sequence data, the predicate $\texttt{region}_{k}$ indicates the $k$ -th region in all regions in a sequence, and the variable $X_{j}$ can be substituted by a subsequence of the sequence data. For example, $\texttt{pattern}_{1}(\mathbf{x}[0:5])$ and $\texttt{region}_{0}(\mathbf{x}[0:5])$ indicate that the subsequence $\mathbf{x}[0:5]$ matches the pattern with index one and belongs to the region with index zero, respectively. A pair of atoms, $\texttt{pattern}_{i}(X)\land\texttt{region}_{k}(X)$ , corresponds to a feature within the sequence data. In this pair, the variables are identical, with one predicate representing a pattern and the other representing a region. We infer the following information from the rules in format (4): In a sequence input $\mathbf{x}$ , if all pairs of ground patterns and regions atoms substituted by subsequences in $\mathbf{x}$ are true, then the sequence input $\mathbf{x}$ belongs to the target class represented by the head atom $h_{t}$ . ### 4.2 Differentiable symbolization process <details> <summary>x1.png Details</summary>  ### Visual Description ## Diagram: Neural Architecture with Differentiable Clustering and Rule Learning ### Overview The diagram illustrates a hybrid neural network architecture combining autoencoding, differentiable clustering, and rule-based prediction. It features an encoder-decoder structure for sequence reconstruction, a differentiable k-means module for unsupervised clustering, and a deep rule learning module for supervised prediction. The architecture integrates multiple loss functions and data flows. ### Components/Axes 1. **Encoder-Decoder Path**: - **Encoder**: - Input: "All subsequences **s** of a series **x**" - Two dense layers → Embeddings **z** - **Decoder**: - Embeddings **z** → Two dense layers → "Reconstructed subsequences **s'**" 2. **Differentiable k-means Module**: - Input: Embeddings **z** - Output: Cluster assignments **r₁, r₂, r₃, r₄** (colored dots: blue, purple, green, orange) - Legend: - Blue: **r₁** - Purple: **r₂** - Green: **r₃** - Orange: **r₄** 3. **Deep Rule Learning Module**: - Input: Cluster assignments **vᵢ** (from **r₁-r₄**) - Output: "Predicted label" via logic programs **P** 4. **Loss Functions**: - **Autoencoder loss** (supervised, orange) - **DeepFOL loss** (supervised, blue) - **Differentiable k-means loss** (unsupervised, gray) 5. **Data Flow**: - Input series **x** → Encoder → Embeddings **z** → Decoder (reconstruction) + Differentiable k-means → Deep rule learning → Predicted label **v(hₜ)** ### Detailed Analysis - **Encoder/Decoder**: Standard dense layer architecture for sequence-to-sequence modeling. - **Differentiable k-means**: Embeddings are clustered into 4 groups (**r₁-r₄**) with color-coded assignments. The "differentiable" aspect implies gradient-based optimization of cluster assignments during training. - **Deep Rule Learning**: Takes cluster assignments as input to predict labels, suggesting rule-based reasoning over learned features. - **Loss Functions**: - Supervised losses (autoencoder, DeepFOL) optimize reconstruction and rule adherence. - Unsupervised loss (differentiable k-means) optimizes cluster quality. ### Key Observations 1. **Hybrid Learning**: Combines supervised (autoencoder, DeepFOL) and unsupervised (k-means) training objectives. 2. **Cluster-Aware Prediction**: The deep rule learning module uses cluster assignments (**vᵢ**) to make predictions, implying rules are applied per-cluster. 3. **Differentiable Clustering**: Unlike traditional k-means, cluster assignments are learned end-to-end via gradients. 4. **Label Prediction**: Final output (**v(hₜ)**) depends on both feature embeddings and cluster membership. ### Interpretation This architecture demonstrates a novel integration of: 1. **Feature Learning**: Autoencoder compresses input sequences into meaningful embeddings. 2. **Unsupervised Structure Discovery**: Differentiable k-means identifies latent clusters in the data. 3. **Rule-Based Reasoning**: The deep rule learning module applies logical programs to cluster-specific patterns. The model's strength lies in its ability to: - Learn compressed representations (**z**) - Discover natural groupings in data (**r₁-r₄**) - Apply interpretable rules to clusters for prediction The use of differentiable clustering is particularly innovative, allowing the model to adapt cluster assignments during training rather than fixing them post-hoc. This could improve performance on dynamic or evolving datasets where cluster structure changes over time. </details> (a) Learning pipeline. <details> <summary>x2.png Details</summary>  ### Visual Description ## Flowchart: Fuzzy Logic System Architecture ### Overview The image depicts a hierarchical fuzzy logic system with input nodes, two processing layers (M1 and M2), and a final output node (h). The system combines input variables (a1-a4) through AND/OR operations with weighted edges, culminating in a disjunctive output. ### Components/Axes - **Nodes**: - **Input Layer (M1)**: Four nodes labeled a1 (0.34), a2 (0.23), a3 (0.36), a4 (0.45) - **First Layer (M1)**: Three nodes combining inputs via AND operations: - a1 ∧ a2 (0.58) - a3 (0.4) - a3 ∧ a4 (0.45) - **Second Layer (M2)**: Two nodes combining first-layer outputs via OR operations: - (a1 ∧ a2 ∧ a3) (0.58) - (a3 ∧ a4) (0.41) - **Output Node (h)**: Final disjunction of second-layer results (0.9) - **Edges**: - Colored orange (first layer) and blue (second layer) - Weights shown as decimal values (e.g., 0.58, 0.4) - **Legend**: - Right-aligned, with: - Blue: "Fuzzy disjunction" (OR operations) - Orange: "Second layer" (M2) ### Detailed Analysis 1. **Input Nodes (M1)**: - a1: 0.34 - a2: 0.23 - a3: 0.36 - a4: 0.45 2. **First Layer (M1)**: - a1 ∧ a2: 0.58 (AND operation) - a3: 0.4 (direct pass-through) - a3 ∧ a4: 0.45 (AND operation) 3. **Second Layer (M2)**: - (a1 ∧ a2 ∧ a3): 0.58 (OR operation combining first-layer nodes) - (a3 ∧ a4): 0.41 (OR operation combining first-layer nodes) 4. **Output Node (h)**: - h ← (a1 ∧ a2 ∧ a3) ∨ (a3 ∧ a4): 0.9 (final fuzzy disjunction) ### Key Observations - **Weight Distribution**: - Highest weight (0.9) on a3 ∧ a4 edge suggests dominant influence from a3 and a4 - Lowest input weight (0.23) on a2 indicates weakest individual contribution - **Layer Progression**: - First-layer weights decrease from 0.58 to 0.4 - Second-layer weights increase from 0.41 to 0.58 - **Final Output**: - h = 0.9 demonstrates strong system activation despite mixed input strengths ### Interpretation This architecture implements a fuzzy logic system where: 1. **Input Aggregation**: Weak individual inputs (a1-a4) are combined through AND operations to form intermediate nodes 2. **Path Diversification**: Two distinct paths emerge: - Path 1: a1 ∧ a2 ∧ a3 (0.58) - Path 2: a3 ∧ a4 (0.41) 3. **Disjunctive Synthesis**: The final OR operation (fuzzy disjunction) combines these paths, with the a3 ∧ a4 path showing stronger influence despite lower individual weights The system appears designed to: - Amplify correlated inputs (a3 appears in both paths) - Create redundancy through parallel processing - Produce a robust output (0.9) even with moderate input strengths Notable anomaly: The a3 node (0.36) has higher weight than a1 (0.34) despite lower input value, suggesting a3 plays a more critical role in the system's logic. </details> (b) Deep rule-learning module. Figure 1: The learning pipeline of NeurRL and the rule-learning module. In this subsection, we design a differentiable body symbolization function $\tilde{L}_{b}$ , inspired by differentiable $k$ -means (Fard et al., 2020), to transform numeric sequence data $\mathbf{x}$ into a fuzzy interpretation vector $\mathbf{v}_{I}\in[0,1]^{n}$ . This vector encodes fuzzy values of ground patterns and region atoms substituted by input subsequences. A higher value in $\mathbf{v}_{I}[i]$ indicates the $i$ -th atom in the interpretation $I$ is likely true. Using the head symbolization function $J=L_{h}(\mathbf{x})$ , we determine the target atom’s Boolean value $v(h_{t})$ , where $v(h_{t})=1$ if $J=\{h_{t}\}$ and $v(h_{t})=0$ if $J=\emptyset$ . Building on (Gao et al., 2024), we learn a logic program matrix $\mathbf{M}_{P}\in[0,1]^{m\times n}$ such that $\tilde{\bigvee}_{i=1}^{m}D_{P}(\mathbf{v}_{I})[i]=v(h_{t})$ holds. The rules in format (4) are then extracted from $\mathbf{M}_{P}$ , generalized from the most specific clause with all pattern and region predicates. The architecture of NeurRL is shown in Fig. 1(a). To learn a logic program $P$ from sequence data, each input sequence $\mathbf{x}$ is divided into shorter subsequences $\mathbf{s}$ of length $l$ with a unit step stride. An encoder maps subsequences $\mathbf{s}$ to an embedding space $\mathbf{z}$ , and a decoder reconstructs $\mathbf{s}^{\prime}$ from $\mathbf{z}$ We use fully connected layers as the encoder and decoder structures.. The differentiable $k$ -means algorithm described in Section 3.2 clusters embeddings $\mathbf{z}$ , grouping subsequences $\mathbf{s}$ with similar patterns into groups $\mathbf{r}$ . This yields fuzzy interpretation vectors $\mathbf{v}_{I}$ and Boolean target atom value $v(h_{t})$ for each sequence. Finally, the differentiable rule-learning module uses $\mathbf{v}_{I}$ as inputs and $v(h_{t})$ as labels to learn high-level rules describing the target class. Now, we describe the method to build the differentiable body symbolization function $\tilde{L}_{b}$ from sequence $\mathbf{x}$ to interpretation vector $\mathbf{v}_{I}$ as follows: Let $K$ be the maximum number of clusters based on the differentiable $k$ -means algorithm, each subsequence $\mathbf{s}$ with the length $l$ in $\mathbf{x}$ and the corresponding embedding $\mathbf{z}$ has a cluster index $c$ $(1\leq c\leq K)$ , and each sequence input $\mathbf{x}$ can be transferred into a vector of cluster indexes $\mathbf{c}\in\{0,1\}^{K\times(\left\lvert\mathbf{x}\right\rvert-l+1)}$ . Additionally, to incorporate temporal or spatial information into the predicates of the target rules, we divide the entire sequence data into $R$ equal regions. The region of a subsequence $\mathbf{s}$ is determined by the location of its first point, $\mathbf{s}[0]$ . For each subsequence $\mathbf{s}$ , we calculate its cluster index vector $\mathbf{c}_{s}\in[0,1]^{K}$ using the weight function $G_{k,f}$ as defined Eq. (2), where $\mathbf{c}_{s}[k]=G_{k,f}(\mathbf{h}_{\gamma}(\mathbf{s}),\alpha;\mathcal{R})$ ( $1\leq k\leq K$ and $\sum_{i=1}^{K}\mathbf{c}_{s}[i]=1$ ). A higher value in the $i$ -th element of $\mathbf{c}_{s}$ indicates that the subsequence $\mathbf{s}$ is more likely to be grouped into the $i$ -th cluster. Hence, we can transfer the sequence input $\mathbf{x}\in\mathbb{R}^{T}$ to cluster index tensor with the possibilities of cluster indexes of subsequences in all regions $\mathbf{c}_{x}\in[0,1]^{K\times l_{p}\times R}$ , where $l_{p}$ is the number of subsequence in one region of input sequence data $\lceil\left\lvert\mathbf{x}\right\rvert/R\rceil$ . To calculate the cluster index possibility of each region, we sum the likelihood of cluster index of all subsequence within one region in cluster index tensor $\mathbf{c}_{x}$ and apply softmax function to build region cluster matrix $\mathbf{c}_{p}\in\mathbb{R}^{K\times R}$ as follows: $$ \displaystyle\mathbf{c}[i,j]=\sum_{k=1}^{l_{p}}\mathbf{c}_{x}[i,k,j],\ \mathbf{c}_{p}[i,j]=\frac{e^{\mathbf{c}[i,j]}}{\sum_{i=1}^{K}e^{\mathbf{c}[i,j]}}. \tag{5} $$ Since the region cluster matrix $\mathbf{c}_{p}$ contains clusters index for each region. Besides, each cluster corresponds to a pattern. Hence, we flatten $\mathbf{c}_{p}$ into a fuzzy interpretation vector $\mathbf{v}_{I}$ , which serves as the input to the deep rule-learning module of NeurRL. ### 4.3 Differentiable rule-learning module In this section, we define the novel deep neural network-based rule-learning module denoted as $N_{R}$ to induce rules from fuzzy interpretation vectors. Based on the label of the sequence input $\mathbf{x}$ , we can determine the Boolean value of target atom $v(h_{t})$ . Then, using fuzzy interpretation vectors $\mathbf{v}_{I}$ as inputs and Boolean values of the head atom $v(h_{t})$ as labels $y$ , we build a novel neural network-based rule-learning module as follows: Firstly, each input node receives the fuzzy value of a pattern or region atom stored in $\mathbf{v}_{I}$ . Secondly, one output node in the final layer reflects the fuzzy values of the head atom. Then, the neural network consists of $k$ dense layers and one disjunction layer. Lastly, let the number of nodes in the $k$ -th dense layer be $m$ , then the forward computation process is formulated as follows: $$ \displaystyle\hat{y}=\tilde{\bigvee}_{i=1}^{m}\left(g_{k}\circ g_{k-1}\circ\dots\circ g_{1}(\mathbf{v}_{I})\right)[i], \tag{6} $$ where the $i$ -th dense layer is defined as: $$ \displaystyle g_{i}(\mathbf{x}_{i-1})=\frac{1}{1-d}\ \text{ReLU}\left({\mathbf{M}}_{i}\mathbf{x}_{i-1}-d\right), \tag{7} $$ with $d$ as the fixed bias In our experiments, we set the fixed bias as 0.5.. The matrix ${\mathbf{M}}_{i}$ is the softmax-activated of trainable weights $\tilde{\mathbf{M}}_{i}\in\mathbb{R}^{n_{\text{out}}\times n_{\text{in}}}$ in $i$ -th dense layer of the rule-learning module: $$ \displaystyle\mathbf{M}_{i}[j,k] \displaystyle=\frac{e^{\tilde{\mathbf{M}}_{i}[j,k]}}{\sum_{u=1}^{n_{\text{in}}}e^{\tilde{\mathbf{M}}_{i}[j,u]}}. \tag{8} $$ With the differentiable body symbolization function $\tilde{L}_{b}$ and $N_{R}$ , we now define a target function that integrates the autoencoder module, clustering module, and rule-learning module as follows: where $\gamma_{e}$ and $\gamma_{l}$ represent the trainable parameters in the encoder and rule-learning module, respectively. The loss function $f_{1}$ and $f_{2}$ are set to mean square error loss and cross-entropy loss correspondingly. The parameters $\lambda_{1}$ and $\lambda_{2}$ regulate the trade-off between finding the concentrated representations of subsequences, the representations of clusters for obtaining precise patterns, and the representations of rules to generalize the data In our experiments, we assigned equal weights to finding representations, identifying clusters, and discovering rules by setting $\lambda_{1}=\lambda_{2}=1$ .. Fig. 1(a) illustrates the loss functions defined in the target function (9). The supervised loss functions are applied to the autoencoder (highlighted in orange boxes) and the rule-learning module (highlighted in blue boxes), respectively. The unsupervised loss function is applied to the differentiable k-means method (highlighted in gray box). We analyze the interpretability of the rule-learning module $N_{R}$ . In the logic program matrix $\mathbf{M}_{P}$ defined in Section 3.1, the sum of non-zero elements in each row, $\sum_{j=1}^{n}\mathbf{M}_{P}[i,j]$ , is normalized to one, matching the threshold in the function $\theta$ in Eq. (1). The conjunction of the atoms corresponding to non-zero elements in each row of $\mathbf{M}_{P}$ can serve as the body of a rule. Similarly, in the rule-learning module of NeurRL, the sum of the softmax-activated weights in each layer is also one. Due to the properties of the activation function $\text{ReLU}(x-d)/(1-d)$ in each node, a node activates only when the sum of the weights approaches one; otherwise, it deactivates. This behavior mimics the threshold function $\theta$ in Eq. (1). Similar to the logic program matrix $\mathbf{M}_{P}$ , the softmax-activated weights in each layer also have interpretability. When the fuzzy interpretation vector and Boolean value of the target atom fit the forward process in Eq. (6), the atoms corresponding to non-zero elements in each row of the $i$ -th dense softmax-activated weight matrix $\mathbf{M}_{i}$ form a conjunction. From a neural network perspective, the $j$ -th node in the $i$ -th dense layer, denoted as $n_{j}^{i}$ , represents a conjunction of atoms from the previous $(i-1)$ -th dense layer (input layer). The likelihood of these atoms appearing in the conjunction is determined by the softmax-activated weights $\mathbf{M}_{i}[j,:]$ connecting to node $n_{j}^{i}$ . In the final $k$ -th dense layer, the disjunction layer computes the probability of the target atom $h_{t}$ . The higher likelihood conjunctions, represented by the nodes in the final $k$ -th layer, form the body of the rule headed by $h_{t}$ . To interpret the rules headed by $h_{t}$ , we compute the product of all softmax-activated weights $\mathbf{M}_{i}$ as the program tensor: $\mathbf{M}_{P}=\prod_{i=1}^{k}\mathbf{M}_{i}$ , where $\mathbf{M}_{P}\in[0,1]^{m\times n}$ . The program tensor has the same interpretability as the program matrix, with high-value atoms in each row forming the rule body and the target atom as the rule head. The number of nodes in the last dense layer $m$ determines the number of learned rules in one learning epoch. Fig. 1(b) shows a neural network with two dense layers and one disjunction layer in blue. The weights in orange represent significant softmax-activated values, with input nodes as atoms and hidden nodes as conjunctions. Multiplying the softmax weights identifies the atoms forming the body of a rule headed by the target atom. We use the following method to extract rules from program tensor $\mathbf{M}_{P}$ : We set multiple thresholds $\tau\in[0,1]$ . When the value of the element in a row of $\mathbf{M}_{P}$ is larger than a threshold $\tau$ , then we regard the atom corresponding to these elements as the body atom in a rule with the format (4). We compute the precision and recall of the rules based on the discretized fuzzy interpretation vectors generated from the test dataset. The discretized fuzzy interpretation vector is derived as the flattened version of $\bar{\mathbf{c}}_{p}[i,j]=\mathbbm{1}(\mathbf{c}_{p}[i,j]=\max_{k}\mathbf{c}_{p}[k,j])$ , where $\max_{k}\mathbf{c}_{p}[k,j]$ represents the maximum value in the $j$ -th column of $\mathbf{c}_{p}$ . Then, we keep the high-precision rules as the output. The precision and recall of a rule are defined as: $\text{precision}={n_{\text{body $\land$ head}}}/{n_{\text{body}}}$ and $\text{recall}={n_{\text{body $\land$ head}}}/n_{\text{head}}$ , where $n_{\text{body $\land$ head}}$ denotes the number of discretized fuzzy interpretation vectors $\mathbf{v}_{I}$ that satisfy the rule body and have the target class as the label. Similarly, $n_{\text{body}}$ represents the number of discretized fuzzy interpretation vectors that satisfy the rule body, while $n_{\text{head}}$ refers to the number of instances with the target class. When obtaining rules in the format (4), we can highlight the subsequences satisfying the pattern and region predicates above on the raw inputs for more intuitive interpretability. To train the model, we first pre-train an autoencoder to obtain subsequence embeddings, then initialize the cluster embeddings using $k$ -means clustering (Lloyd, 1982) based on these embeddings. Finally, we jointly train the autoencoder, clustering model, and rule-learning model using the target function (9) to optimize the embeddings, clusters, and rules simultaneously. ## 5 Experimental results <details> <summary>x3.png Details</summary>  ### Visual Description ## Line Graph: h_p ← pattern₀(X) ∧ region₁(X) (p = 1, r = 1) ### Overview The image depicts a line graph comparing two opposing trends labeled "Positive" (blue) and "Negative" (orange) across 15 time points (0–14). The graph includes a legend in the top-right corner and a title referencing a logical relationship between pattern and region functions with parameters p=1 and r=1. ### Components/Axes - **X-axis**: "Time points" (0, 2, 4, 6, 8, 10, 12, 14) - **Y-axis**: "Value" (0.0 to 1.0 in 0.2 increments) - **Legend**: Top-right corner, with blue = "Positive", orange = "Negative" - **Title**: "h_p ← pattern₀(X) ∧ region₁(X) (p = 1, r = 1)" (top-center) ### Detailed Analysis 1. **Positive Line (Blue)**: - Starts at 0.0 (time 0) - Rises sharply to ~1.0 at time 4 - Drops to 0.0 at time 8 - Rises again to ~1.0 at time 14 - Crosses the Negative line at ~time 2, 6, and 10 2. **Negative Line (Orange)**: - Starts at ~0.9 at time 0 - Drops to 0.0 at time 4 - Rises to ~1.0 at time 8 - Drops to 0.0 at time 14 - Crosses the Positive line at ~time 2, 6, and 10 3. **Key Intersection Points**: - Time 2: Positive ~0.4, Negative ~0.6 - Time 6: Positive ~0.8, Negative ~0.2 - Time 10: Positive ~0.0, Negative ~0.9 ### Key Observations - The lines exhibit **inverse proportionality**: when one peaks, the other troughs. - Both lines reach 0.0 at distinct time points (Positive at 0, 8, 14; Negative at 4, 14). - The graph suggests a **cyclical or alternating pattern** between positive and negative states. ### Interpretation The data demonstrates a **binary opposition** between "Positive" and "Negative" values over time, with strict alternation between states. The parameters p=1 and r=1 in the title may indicate a simplified model (e.g., binary classification or threshold-based system). The intersections at times 2, 6, and 10 suggest critical transition points where the system switches states. The absence of intermediate values (e.g., 0.5) implies a **digital rather than analog** representation of the data. This could reflect a theoretical framework where opposing forces (e.g., activation/inhibition, presence/absence) dominate at discrete intervals. </details> (a) The signals based on triangular pulse. <details> <summary>x4.png Details</summary>  ### Visual Description ## Line Graph: h_p ← pattern₀(X) ∧ region₂(X) (p = 1, r = 1) ### Overview The image is a line graph depicting two oscillating data series labeled "Positive" (blue) and "Negative" (orange). The graph spans 15 time points (0–14) on the x-axis and values from 0.0 to 1.0 on the y-axis. The lines intersect multiple times, suggesting inverse relationships between the two series. ### Components/Axes - **Title**: "h_p ← pattern₀(X) ∧ region₂(X) (p = 1, r = 1)" (top-center) - **X-axis**: "Time points" (0–14, increments of 2) - **Y-axis**: "Value" (0.0–1.0, increments of 0.2) - **Legend**: Top-left corner, with: - Blue line: "Positive" - Orange line: "Negative" ### Detailed Analysis 1. **Positive Series (Blue)**: - Starts at ~0.4 (time 0). - Peaks at 1.0 (time 2). - Drops to 0.0 (time 6). - Rises to 1.0 (time 10). - Falls to ~0.1 (time 14). - **Trend**: Oscillates with peaks at even time points (2, 10) and troughs at odd multiples of 6. 2. **Negative Series (Orange)**: - Starts at ~0.4 (time 0). - Drops to 0.0 (time 2). - Peaks at 1.0 (time 6). - Drops to 0.0 (time 10). - Rises to 1.0 (time 14). - **Trend**: Oscillates with peaks at odd multiples of 6 (6, 14) and troughs at even time points (2, 10). 3. **Intersections**: - Lines cross at ~time 4, 8, and 12, where values transition between positive and negative dominance. ### Key Observations - **Inverse Relationship**: The "Positive" and "Negative" series peak at alternating time points, suggesting a cyclical opposition. - **Symmetry**: Both series exhibit similar amplitude (0.0–1.0) but phase-shifted by 4 time units. - **Final State**: At time 14, the "Negative" series dominates (~0.9), while "Positive" is near 0.1. ### Interpretation The graph likely models a system where two opposing states (e.g., signal polarities, economic indicators) alternate predictably over time. The parameters `p = 1` and `r = 1` may denote a baseline configuration (e.g., periodicity or region size). The consistent oscillations imply a deterministic process, while the intersections highlight transitional states. The final dominance of the "Negative" series could indicate a long-term trend or external influence not captured by the cyclical pattern. </details> (b) The signals based on trigonometry function. Figure 2: The synthetic data and the learned rules. ### 5.1 Learning from synthetic data In this subsection, we evaluate the model on synthetic time series data based on triangular pulse signals and trigonometric signals. Each signal contains two key patterns, increasing and decreasing, with each pattern having a length of five units. To test NeurRL’s learning capability on a smaller dataset, we set the number of inputs in both the positive and negative classes to two for both the training and test datasets. In each class, the difference between two inputs at each time point is a random number drawn from a normal distribution with a mean of zero and a variance of 0.1. The positive test inputs are plotted in blue, and the negative test inputs in orange in Fig. 2. We set both the length of each region and the subsequence length to five units, and the number of clusters is set to three in this experiment. NeurRL is tasked with learning rules to describe the positive class, represented by the head atom $h_{p}$ . If the ground body atoms, substituted by subsequences of an input, hold true, the head atom $h_{p}$ is also true, indicating that the target class of the input is positive. The rules with 1.0 precision ( $p$ ) and 1.0 recall ( $r$ ) are shown in Fig. 2. The rule in Fig. 2(a) states that when $\texttt{pattern}_{0}$ (cluster index 0) appears in $\texttt{region}_{1}$ (from time points 5 to 9), the time series label is positive. Similarly, the rule in Fig. 2(b) indicates that when $\texttt{pattern}_{0}$ appears in $\texttt{region}_{2}$ (from time points 10 to 14), the label is positive. We highlight subsequences that satisfy the rule body in red in Fig. 2, inferring that the $\texttt{pattern}_{0}$ indicates decreasing. These red patterns perfectly distinguish positive from negative inputs. ### 5.2 Learning from UCR datasets <details> <summary>x5.png Details</summary>  ### Visual Description ## Line Graph: Logical Relationship Between Patterns and Regions (p = 0.83, r = 0.89) ### Overview The image depicts a line graph comparing two time-series datasets labeled "Positive" (solid blue line) and "Negative" (dashed orange line). The graph spans 80 time points on the x-axis and values between 0.0 and 0.8 on the y-axis. The title includes a logical expression involving pattern/region relationships with statistical metrics (p = 0.83, r = 0.89). ### Components/Axes - **X-axis**: "Time points" (0–80, linear scale) - **Y-axis**: "Value" (0.0–0.8, linear scale) - **Legend**: Located in the top-right corner, with: - Solid blue line: "Positive" - Dashed orange line: "Negative" - **Title**: Positioned at the top, containing a logical formula: `h_p ← pattern₂(X) ∧ region₁(X) ∧ pattern₁(Y) ∧ region₂(Y) (p = 0.83, r = 0.89)` ### Detailed Analysis 1. **Positive (Blue Line)**: - Starts at ~0.75 at time point 0. - Drops sharply to ~0.2 by time point 10. - Rises to ~0.6 by time point 20, then fluctuates between 0.4–0.6 until time point 40. - Peaks at ~0.8 at time point 80. 2. **Negative (Orange Line)**: - Begins at ~0.3 at time point 0. - Rises to ~0.5 by time point 20, then stabilizes between 0.4–0.5 until time point 60. - Spikes to ~0.7 at time point 80. 3. **Intersection**: The lines cross near time point 20, where the blue line dips below the orange line before diverging again. ### Key Observations - **Correlation**: The high r-value (0.89) suggests a strong positive correlation between the two datasets. - **Divergence**: The datasets diverge significantly after time point 20, with the "Positive" line showing greater volatility. - **Outlier**: The "Negative" line's sharp spike at time point 80 deviates from its earlier stability. ### Interpretation The graph illustrates a dynamic relationship between two variables over time, with the "Positive" dataset exhibiting higher initial values and greater variability, while the "Negative" dataset remains more stable until the final time point. The logical expression in the title implies that the observed correlation (r = 0.89) supports a combined pattern-region relationship, though the p-value (0.83) suggests this relationship is not statistically significant at conventional thresholds (e.g., p < 0.05). The divergence at time point 80 may indicate an external factor influencing the "Negative" dataset. The strong correlation coefficient implies that the two variables are closely related, but the lack of statistical significance in the p-value warrants caution in drawing definitive conclusions. </details> (a) A rule from ECG dataset. <details> <summary>x6.png Details</summary>  ### Visual Description ## Line Chart: Hypothesis Testing Results (h_p ← pattern₀(X) ∧ region₆(X)) ### Overview The chart visualizes the evolution of two statistical measures ("Positive" and "Negative") over 20 time points. The title indicates a hypothesis test with high statistical significance (p = 0.99) and strong correlation (r = 0.90). A red arrow highlights a critical region near time point 18. ### Components/Axes - **X-axis**: "Time points" (0–20, linear scale). - **Y-axis**: "Value" (0.1–0.8, linear scale). - **Legend**: Top-left corner, labels: - **Positive**: Solid blue lines. - **Negative**: Dashed orange lines. - **Title**: Top of the chart, includes formula `h_p ← pattern₀(X) ∧ region₆(X)` with parameters `p = 0.99, r = 0.90`. - **Red Arrow**: Points to a cluster of lines near time point 18. ### Detailed Analysis - **Positive (Blue Solid Lines)**: - Starts near 0.3 at time 0. - Dips below 0.2 between time 5–10. - Rises sharply to 0.7–0.8 between time 15–20. - Shows high variability (e.g., peaks at ~0.8 at time 20). - **Negative (Orange Dashed Lines)**: - Starts near 0.2 at time 0. - Rises to ~0.6 between time 5–10. - Drops below 0.3 after time 15. - Exhibits erratic fluctuations (e.g., sharp drop at time 18). - **Red Arrow**: - Points to a dense cluster of lines (~0.4–0.6 value range) at time 18. - Overlaps with both Positive and Negative lines, suggesting a critical interaction. ### Key Observations 1. **Divergence at Time 18**: The red arrow highlights a region where Positive and Negative lines intersect or cluster, indicating a potential anomaly or pivotal event. 2. **Trend Reversal**: Positive values surge after time 15, while Negative values decline sharply post-time 15. 3. **Statistical Significance**: High p (0.99) and r (0.90) values suggest the observed patterns are robust and strongly correlated. ### Interpretation The chart demonstrates a dynamic relationship between "Positive" and "Negative" measures over time. The high p-value confirms the hypothesis test’s reliability, while the r-value indicates a strong linear association between the variables. The red arrow’s focus on time 18 suggests this point marks a critical transition, possibly where the Positive trend overtakes the Negative trend. The overlapping lines in this region may reflect a feedback loop or external influence altering the system’s behavior. The divergence post-time 18 could imply a tipping point or threshold effect in the modeled system. </details> (b) A rule from ItalyPow.Dem. dataset. Figure 3: Selected rules from two UCR datasets. In this subsection, we experimentally demonstrate the effectiveness of NeurRL on 13 randomly selected datasets from UCR (Dau et al., 2019), as used by Wang et al. (2019). To evaluate NeurRL’s performance, we consider the classification accuracy from the rules extracted by the deep rule-learning module (denoted as NeurRL(R)) and the classification accuracy from the module itself (denoted as NeurRL(N)). The number of clusters in this experiment is set to five. The subsequence length and the number of regions vary for each task. We set the number of regions to approximately 10 for time series data. Additionally, the subsequence length is set to range from two to five, depending on the specific subtask. The baseline models include SSSL (Wang et al., 2019), Xu (Xu and Funaya, 2015), and BoW (Wang et al., 2013). SSSL uses regularized least squares, shapelet regularization, spectral analysis, and pseudo-labeling to auto-learn discriminative shapelets from time series data. Xu’s method constructs a graph to derive underlying structures of time series data in a semi-supervised way. BoW generates a bag-of-words representation for time series and uses SVM for classification. Statistical details, such as the number of classes (C.), inputs (I.), series length, and comparison results are shown in Tab. 1, with the best results in bold and second-best underlined. The NeurRL(N) achieves the most best results, with seven, and NeurRL(R) achieves five second-best results. Table 1: Classification accuracy on 13 binary UCR datasets with different models. | Coffee | 2 | 56 | 286 | 0.588 | 0.620 | 0.792 | 0.964 | 1.000 | | --- | --- | --- | --- | --- | --- | --- | --- | --- | | ECG | 2 | 200 | 96 | 0.819 | 0.955 | 0.793 | 0.820 | 0.880 | | Gun point | 2 | 200 | 150 | 0.729 | 0.925 | 0.824 | 0.760 | 0.873 | | ItalyPow.Dem. | 2 | 1096 | 24 | 0.772 | 0.813 | 0.941 | 0.926 | 0.923 | | Lighting2 | 2 | 121 | 637 | 0.698 | 0.721 | 0.813 | 0.689 | 0.748 | | CBF | 3 | 930 | 128 | 0.921 | 0.873 | 1.000 | 0.909 | 0.930 | | Face four | 4 | 112 | 350 | 0.833 | 0.744 | 0.851 | 0.914 | 0.964 | | Lighting7 | 7 | 143 | 319 | 0.511 | 0.677 | 0.796 | 0.737 | 0.878 | | OSU leaf | 6 | 442 | 427 | 0.642 | 0.685 | 0.835 | 0.844 | 0.849 | | Trace | 4 | 200 | 275 | 0.788 | 1.00 | 1.00 | 0.833 | 0.905 | | WordsSyn | 25 | 905 | 270 | 0.639 | 0.795 | 0.875 | 0.932 | 0.946 | | OliverOil | 4 | 60 | 570 | 0.639 | 0.766 | 0.776 | 0.768 | 0.866 | | StarLightCurves | 3 | 9236 | 2014 | 0.755 | 0.851 | 0.872 | 0.869 | 0.907 | | Mean accuracy | | | | 0.718 | 0.801 | 0.859 | 0.842 | 0.891 | The learned rules from the ECG and ItalyPow.Dem. datasets in the UCR archive are shown in Fig. 3. In Fig. 3(a), red highlights subsequences with the shape $\texttt{pattern}_{2}$ in the region $\texttt{region}_{1}$ , while green highlights subsequences with the shape $\texttt{pattern}_{1}$ in the region $\texttt{region}_{2}$ . The rule suggests that when data decreases between time points 15 to 25 and then increases between time points 30 to 40, the input likely belongs to the positive class. The precision and recall for this rule are 0.83 and 0.89, respectively. In Fig. 3(b), red highlights subsequences with the shape $\texttt{pattern}_{0}$ in the region $\texttt{region}_{6}$ . The rule indicates that a lower value around time points 18 to 19 suggests the input belongs to the positive class, with precision and recall of 0.99 and 0.90, respectively. <details> <summary>x7.png Details</summary>  ### Visual Description ## Diagram: Binary Classification Visualization ### Overview The image depicts a binary classification scenario with two distinct regions labeled "positive class" and "negative class." Each region contains a pixelated shape and associated visual elements. Below both regions, the text "p = 1, r = 1" is displayed, likely indicating precision (p) and recall (r) metrics. ### Components/Axes - **Left Region (Positive Class)**: - Label: "positive class" (centered below the region). - Visual Elements: - A vertical white line (diagonal orientation) occupying the central portion. - Five colored horizontal rectangles (red, green, blue, yellow, purple) aligned to the left of the line. - **Right Region (Negative Class)**: - Label: "negative class" (centered below the region). - Visual Elements: - A pixelated circular shape (white with black background). - **Text Below**: - "p = 1, r = 1" (centered below both regions). ### Detailed Analysis - **Positive Class**: - The vertical line and colored rectangles suggest a structured or segmented representation, possibly indicating features or attributes. - No explicit legend or axis markers are present, but the colored rectangles may imply categorical data (e.g., feature importance or thresholds). - **Negative Class**: - The circular shape is uniform and lacks additional annotations, suggesting a simpler or more homogeneous representation. - **Text**: - "p = 1, r = 1" implies perfect precision and recall, though this is unusual in real-world scenarios and may represent an idealized or synthetic example. ### Key Observations 1. The positive class is visually more complex (line + colored bars) compared to the negative class (single shape). 2. The absence of a legend or axis scales limits quantitative interpretation of the colored rectangles. 3. The text "p = 1, r = 1" is the only explicit numerical data, but its validity depends on context not provided in the image. ### Interpretation This diagram likely illustrates a simplified binary classification task, where the positive class is represented by a structured pattern (line and colored bars) and the negative class by a circular shape. The "p = 1, r = 1" values suggest an idealized model with no false positives or negatives, which is unrealistic in practice. The colored rectangles in the positive class may symbolize distinct features or decision boundaries, but their exact meaning is unclear without additional context. The image emphasizes visual differentiation between classes rather than quantitative analysis. </details> Figure 4: Learned rules from MNIST datasets. To demonstrate the benefits of the fully differentiable learning pipeline from raw sequence inputs to symbolic rules, we compare the accuracy and running times (in seconds) between NeurRL and its deep rule-learning module using the non-differentiable $k$ -means clustering algorithm (Lloyd, 1982). We use the same hyperparameter to split time series into subsequences for two methods. Results in Tab. 2 show that the differentiable pipeline significantly reduces running time without sacrificing rule accuracy in most cases. Table 2: Comparisons with non-differentiable $k$ -means clustering algorithm. | Coffee | 0.893 | 313 | 0.964 | 42 | | --- | --- | --- | --- | --- | | ECG | 0.810 | 224 | 0.820 | 65 | | Gun point | 0.807 | 102 | 0.740 | 35 | | ItalyPow.Dem. | 0.845 | 114 | 0.926 | 63 | | Lighting2 | 0.672 | 1166 | 0.689 | 120 | ### 5.3 Learning from images In this subsection, we ask the model to learn rules to describe and discriminate two classes of images from MNIST datasets. We divide the MNIST dataset into five independent datasets, where each dataset contains one positive class and one negative class. For two-dimensional image data, we first flatten the image data to one-dimensional sequence data. Then, the sequence data can be the input for the NeurRL model to learn the rules. The lengths of subsequence and region are both set to three. Besides, the number of clusters is set to five. After generating the highlighted patterns based on the rules, we recover the sequence data to the image for interpreting these learned rules. We present the rule for learning the digit one from the digit zero in Fig. 4, and the rules for learning other positive class from the negative class are shown in Fig. 6 in Appendix C. We present the rule with the precision larger than 0.9 and the highlight features (or areas) defined in the rules. Each highlight feature corresponds to a pair of region and pattern atoms in a learned rule. We can interpret rules like importance attention (Zhang et al., 2019), where the colored areas include highly discriminative information for describing positive inputs compared with negative inputs. For example, in Fig. 4, if the highlighted areas are in black at the same time, then the image class is one. Otherwise, the image class is zero. Compared with attention, we calculate the precision and recall to evaluate these highlight features quantitatively. ### 5.4 Ablation study We conducted ablation studies using default hyperparameters, except for the one being explored. In this study, the number of clusters and regions influences the number of atoms in the learned rules, while the length of subsequences depends on the length of potential patterns. Hence, these three hyperparameters collectively describe the sensitivity of NeurRL. We present the accuracy of both NeurRL(N) and NeurRL(R) on the time series tasks ECG and ItalyPow.Dem. from the UCR archive. <details> <summary>x8.png Details</summary>  ### Visual Description ## Line Graphs: Performance Comparison of NeurRL(N) and NeurRL(R) Across Parameters ### Overview The image contains three line graphs comparing the performance of two models, **NeurRL(N)** (blue) and **NeurRL(R)** (orange), across three distinct parameters: 1. **Number of Clusters** (x-axis: 2–6) 2. **Length of Regions** (x-axis: 2–6) 3. **Length of Subsequence** (x-axis: 3–7) The y-axis represents a normalized performance metric (0.0–1.0) for all graphs. Both models exhibit similar trends, with **NeurRL(N)** consistently outperforming **NeurRL(R)** by small margins. --- ### Components/Axes #### Common Elements: - **Legend**: Located at the bottom-right corner of all graphs, with: - Blue circles: **NeurRL(N)** - Orange circles: **NeurRL(R)** - **Y-axis**: Labeled "Performance Metric" (0.0–1.0 in increments of 0.2). - **X-axes**: 1. **Number of Clusters**: 2–6 (integer values). 2. **Length of Regions**: 2–6 (integer values). 3. **Length of Subsequence**: 3–7 (integer values). #### Graph-Specific Details: 1. **Number of Clusters**: - **NeurRL(N)**: Peaks at ~0.88 (4 clusters), dips to ~0.78 (3 clusters), stabilizes at ~0.85 (5–6 clusters). - **NeurRL(R)**: Peaks at ~0.85 (4 clusters), dips to ~0.75 (2 clusters), stabilizes at ~0.83 (5–6 clusters). 2. **Length of Regions**: - **NeurRL(N)**: Peaks at ~0.88 (2 regions), dips to ~0.85 (3 regions), stabilizes at ~0.87 (4–6 regions). - **NeurRL(R)**: Peaks at ~0.87 (3 regions), dips to ~0.78 (4 regions), stabilizes at ~0.85 (5–6 regions). 3. **Length of Subsequence**: - **NeurRL(N)**: Peaks at ~0.88 (3 subsequences), dips to ~0.86 (4 subsequences), stabilizes at ~0.87 (5–7 subsequences). - **NeurRL(R)**: Peaks at ~0.85 (3 subsequences), dips to ~0.82 (4 subsequences), stabilizes at ~0.84 (5–7 subsequences). --- ### Detailed Analysis #### Trends: - **NeurRL(N)** consistently outperforms **NeurRL(R)** across all parameters, with performance differences ranging from ~0.03 to ~0.06. - Both models show **plateaus** after optimal parameter values (e.g., 4 clusters, 4 regions, 5 subsequences), suggesting diminishing returns beyond these points. - **NeurRL(R)** exhibits sharper dips in performance at specific parameter values (e.g., 4 regions, 4 subsequences) compared to **NeurRL(N)**. #### Spatial Grounding: - Legends are consistently positioned at the **bottom-right** of all graphs. - Data points align with legend colors: blue for **NeurRL(N)**, orange for **NeurRL(R)**. --- ### Key Observations 1. **Performance Gaps**: - **NeurRL(N)** maintains a ~0.03–0.06 advantage over **NeurRL(R)** in all graphs. - Largest gap observed in the **Number of Clusters** graph (0.03 at 2 clusters). 2. **Parameter Sensitivity**: - **NeurRL(R)** is more sensitive to parameter changes (e.g., sharp dip at 4 regions). - **NeurRL(N)** shows smoother performance curves with fewer fluctuations. 3. **Optimal Parameters**: - **NeurRL(N)**: Optimal at 4 clusters, 2 regions, and 5 subsequences. - **NeurRL(R)**: Optimal at 4 clusters, 3 regions, and 3 subsequences. --- ### Interpretation The data suggests that **NeurRL(N)** is more robust to parameter variations, maintaining higher performance across all tested configurations. The plateaus indicate that increasing parameters beyond certain thresholds (e.g., >4 clusters) yields minimal gains, highlighting potential inefficiencies in scaling. **NeurRL(R)**’s sharper dips suggest it may struggle with specific parameter configurations, requiring careful tuning. These trends could inform model selection based on the trade-off between performance stability and parameter sensitivity. </details> (a) On ECG dataset. <details> <summary>x9.png Details</summary>  ### Visual Description ## Line Chart: Performance Metrics Across Parameters ### Overview The image displays three line charts comparing the performance of two algorithms, **NeurRL(N)** (blue) and **NeurRL(R)** (orange), across three distinct parameters: **Number of Clusters**, **Length of Regions**, and **Length of Subsequence**. Each chart uses a y-axis scaled from 0.0 to 1.0 and an x-axis with discrete integer values. The charts highlight trends in performance as the parameters vary. --- ### Components/Axes 1. **X-Axes**: - **Left Panel**: "Number of Clusters" (values: 2, 3, 4, 5, 6). - **Middle Panel**: "Length of Regions" (values: 2, 3, 4, 5, 6). - **Right Panel**: "Length of Subsequence" (values: 2, 3, 4, 5, 6, 7, 8). 2. **Y-Axis**: All panels share a y-axis labeled "Performance Score" (range: 0.0 to 1.0). 3. **Legends**: Located in the bottom-right corner of each panel, with: - **Blue Circles**: NeurRL(N) - **Orange Circles**: NeurRL(R) --- ### Detailed Analysis #### Left Panel: Number of Clusters - **NeurRL(N)** (blue): - Starts at ~0.95 (x=2), dips to ~0.65 (x=3), rises to ~0.8 (x=4), fluctuates to ~0.75 (x=5), and stabilizes at ~0.8 (x=6). - **NeurRL(R)** (orange): - Begins at ~0.85 (x=2), drops to ~0.55 (x=3), rises to ~0.7 (x=4), dips to ~0.65 (x=5), and stabilizes at ~0.75 (x=6). #### Middle Panel: Length of Regions - **NeurRL(N)** (blue): - Peaks at ~0.95 (x=2), dips to ~0.8 (x=3), fluctuates to ~0.75 (x=4), rises to ~0.85 (x=5), and stabilizes at ~0.8 (x=6). - **NeurRL(R)** (orange): - Starts at ~0.75 (x=2), peaks at ~0.8 (x=3), drops sharply to ~0.55 (x=4), rises to ~0.75 (x=5), and stabilizes at ~0.7 (x=6). #### Right Panel: Length of Subsequence - **NeurRL(N)** (blue): - Begins at ~0.9 (x=2), dips to ~0.75 (x=3), fluctuates to ~0.8 (x=4), rises to ~0.85 (x=5), dips to ~0.75 (x=6), rises to ~0.9 (x=7), and stabilizes at ~0.8 (x=8). - **NeurRL(R)** (orange): - Starts at ~0.95 (x=2), drops sharply to ~0.55 (x=3), rises to ~0.6 (x=4), fluctuates to ~0.7 (x=5), dips to ~0.65 (x=6), rises to ~0.9 (x=7), and stabilizes at ~0.8 (x=8). --- ### Key Observations 1. **NeurRL(N)** (blue) generally shows higher performance scores across most parameters but exhibits sharper dips (e.g., at x=3 in all panels). 2. **NeurRL(R)** (orange) demonstrates more stability in the **Number of Clusters** and **Length of Subsequence** panels but suffers a significant dip at x=4 in the **Length of Regions** panel. 3. Both algorithms show similar performance trends in the **Length of Subsequence** panel, with NeurRL(R) starting higher but converging with NeurRL(N) at x=8. --- ### Interpretation The data suggests that **NeurRL(N)** and **NeurRL(R)** respond differently to parameter changes: - **NeurRL(N)** may prioritize adaptability, excelling in scenarios with fewer clusters or shorter subsequences but struggling with mid-range values (e.g., x=3 in all panels). - **NeurRL(R)** appears more robust in handling larger subsequences (x=7–8) but is sensitive to mid-range region lengths (x=4). - The dips in performance (e.g., x=3, x=4) could indicate overfitting, computational constraints, or parameter mismatches. Further investigation into the algorithms' architectures or training data might clarify these trends. </details> (b) On ItalyPow.Dem. dataset. Figure 5: Results of ablation study. Hyperparameter values vs. accuracy. From Fig. 5, we observe that NeurRL’s sensitivity varies across tasks, and the subsequence length is a sensitive hyperparameter when the sequence length is small, as seen in the ItalyPow.Dem. dataset. Properly chosen hyperparameters can achieve high consistency in accuracy between rules and neural networks. Notably, increasing the number of clusters or length of regions does not reduce accuracy linearly. This suggests that the rule-learning module effectively adjusts clusters within the model. In addition, we conduct another ablation study in Tab. 3 of Appendix A to show that pre-training the autoencoder and clustering prevents cluster collapse (Sansone, 2023) and improves accuracy without increasing significant training time. ## 6 Conclusion Inductive logic programming (ILP) is a rule-based machine learning method that supporting data interpretability. Differentiable ILP offers advantages in scalability and robustness. However, label leakage remains a challenge when learning rules from raw data, as neuro-symbolic models require intermediate feature labels as input. In this paper, we propose a novel fully differentiable ILP model, Neural Rule Learner (NeurRL), which learns symbolic rules from raw sequences using a differentiable $k$ -means clustering module and a deep neural network-based rule-learning module. The differentiable $k$ -means clustering algorithm groups subcomponents of inputs based on the similarity of their embeddings, and the learned clusters are used as input for the rule-learning module to induce rules that describe the ground truth class of input based on its features. Compared to other rule-based models, NeurRL achieves comparable classification accuracy while offering interpretability through quantitative metrics. Future goals include variables representing entire inputs to explain handwritten digits without label leakage (Evans et al., 2021). Another focus is learning from incomplete data (e.g., healthcare applications) to address real-world challenges. #### Acknowledgments We express our gratitude to the anonymous Reviewers for their valuable feedback, which has contributed significantly to enhancing the clarity and presentation of our paper. We also thank Xingyao Wang, Yingzhi Xia, Yang Liu, Jasmine Ong, Justina Ma, Jonathan Tan, Yong Liu, and Rick Goh for their supporting. This work has been supported by AI Singapore under Grant AISG2TC2022006, Singapore. This work has been supported by the NII international internship program, JSPS KAKENHI Grant Number JP21H04905 and JST CREST Grant Number JPMJCR22D3, Japan. This work has also been supported by the National Key R&D Program of China under Grant 2021YFF1201102 and the National Natural Science Foundation of China under Grants 61972005 and 62172016. ## References - K. R. Apt, H. A. Blair, and A. Walker (1988) Towards a theory of declarative knowledge. In Foundations of Deductive Databases and Logic Programming, pp. 89–148. Cited by: §3.1. - S. Azzolin, A. Longa, P. Barbiero, P. Liò, and A. Passerini (2023) Global explainability of gnns via logic combination of learned concepts. In Proceedings of the 11th International Conference on Learning Representations, ICLR-23, Cited by: §2. - H. Blockeel and L. De Raedt (1998) Top-down induction of first-order logical decision trees. Artif. Intell. 101 (1-2), pp. 285–297. Cited by: §1. - A. Cropper, S. Dumancic, R. Evans, and S. H. Muggleton (2022) Inductive logic programming at 30. Mach. Learn. 111 (1), pp. 147–172. Cited by: §1. - A. Cropper and S. Dumancic (2022) Inductive logic programming at 30: A new introduction. J. Artif. Intell. Res. 74, pp. 765–850. Cited by: §2. - G. Das, K. Lin, H. Mannila, G. Renganathan, and P. Smyth (1998) Rule discovery from time series. In Proceedings of the Fourth International Conference on Knowledge Discovery and Data Mining (KDD-98), pp. 16–22. Cited by: §2, §3.2. - H. A. Dau, A. Bagnall, K. Kamgar, C. M. Yeh, Y. Zhu, S. Gharghabi, C. A. Ratanamahatana, and E. Keogh (2019) The UCR time series archive. IEEE/CAA Journal of Automatica Sinica 6 (6), pp. 1293–1305. Note: https://www.cs.ucr.edu/~eamonn/time_series_data_2018/ Cited by: §5.2. - L. De Raedt and L. Dehaspe (1997) Clausal discovery. Mach. Learn. 26 (2-3), pp. 99–146. Cited by: §3.1. - F. Doshi-Velez and B. Kim (2017) Towards a rigorous science of interpretable machine learning. arXiv preprint arXiv:1702.08608. Cited by: §1. - R. Evans, M. Bosnjak, L. Buesing, K. Ellis, D. P. Reichert, P. Kohli, and M. J. Sergot (2021) Making sense of raw input. Artif. Intell. 299, pp. 103521. Cited by: §1, §2, §6. - R. Evans and E. Grefenstette (2018) Learning explanatory rules from noisy data. J. Artif. Intell. Res. 61, pp. 1–64. Cited by: §1, §2, §2, §3.1. - M. M. Fard, T. Thonet, and É. Gaussier (2020) Deep k -means: jointly clustering with k -means and learning representations. Pattern Recognit. Lett. 138, pp. 185–192. Cited by: §3.2, §4.2. - K. Gao, K. Inoue, Y. Cao, and H. Wang (2022a) Learning first-order rules with differentiable logic program semantics. In Proceedings of the 31st International Joint Conference on Artificial Intelligence, IJCAI-22, pp. 3008–3014. Cited by: §1, §2, §3.1. - K. Gao, K. Inoue, Y. Cao, and H. Wang (2024) A differentiable first-order rule learner for inductive logic programming. Artif. Intell. 331, pp. 104108. Cited by: §1, §2, §3.1, §3.1, §4.2. - K. Gao, H. Wang, Y. Cao, and K. Inoue (2022b) Learning from interpretation transition using differentiable logic programming semantics. Mach. Learn. 111 (1), pp. 123–145. Cited by: §2. - Y. He, X. Chu, G. Peng, Y. Wang, Z. Jin, and X. Wang (2018) Mining rules from real-valued time series: A relative information-gain-based approach. In 2018 IEEE 42nd Annual Computer Software and Applications Conference, COMPSAC-18, pp. 388–397. Cited by: §2. - C. Hocquette, A. Niskanen, M. Järvisalo, and A. Cropper (2024) Learning MDL logic programs from noisy data. In Proceedings of the 39th Annual AAAI Conference on Artificial Intelligence, AAAI-24, pp. 10553–10561. Cited by: §1. - K. Inoue, T. Ribeiro, and C. Sakama (2014) Learning from interpretation transition. Mach. Learn. 94 (1), pp. 51–79. Cited by: §2, §3.1. - E. Jang, S. Gu, and B. Poole (2017) Categorical reparameterization with gumbel-softmax. In Proceedings of the 5th International Conference on Learning Representations, ICLR-17, Cited by: §3.2. - Z. Liu, Y. Wang, S. Vaidya, F. Ruehle, J. Halverson, M. Soljacic, T. Y. Hou, and M. Tegmark (2024) KAN: kolmogorov-arnold networks. CoRR abs/2404.19756. Cited by: §2. - J. W. Lloyd (1984) Foundations of logic programming, 1st edition. Springer. Cited by: §3.1, §3.1. - S. P. Lloyd (1982) Least squares quantization in PCM. IEEE Trans. Inf. Theory 28 (2), pp. 129–136. Cited by: §4.3, §5.2. - R. Manhaeve, S. Dumancic, A. Kimmig, T. Demeester, and L. D. Raedt (2018) DeepProbLog: neural probabilistic logic programming. In Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems, NeurIPS-18, pp. 3753–3763. Cited by: §1, §2. - E. Marconato, G. Bontempo, E. Ficarra, S. Calderara, A. Passerini, and S. Teso (2023) Neuro-symbolic continual learning: knowledge, reasoning shortcuts and concept rehearsal. In Proceedings of the 40th International Conference on Machine Learning, ICML-23, Vol. 202, pp. 23915–23936. Cited by: §4.1. - E. Misino, G. Marra, and E. Sansone (2022) VAEL: bridging variational autoencoders and probabilistic logic programming. In Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems, NeurIPS-22, Cited by: §2. - S. H. Muggleton and L. De Raedt (1994) Inductive logic programming: theory and methods. J. Log. Program. 19/20, pp. 629–679. Cited by: §2. - S. H. Muggleton and C. Feng (1990) Efficient induction of logic programs. In Algorithmic Learning Theory, First International Workshop, ALT-90, pp. 368–381. Cited by: §2. - S. H. Muggleton, L. D. Raedt, D. Poole, I. Bratko, P. A. Flach, K. Inoue, and A. Srinivasan (2012) ILP turns 20 - biography and future challenges. Mach. Learn. 86 (1), pp. 3–23. Cited by: §3.1. - A. Passerini, P. Frasconi, and L. D. Raedt (2006) Kernels on prolog proof trees: statistical learning in the ILP setting. J. Mach. Learn. Res. 7, pp. 307–342. Cited by: §3.1. - Y. J. Phua and K. Inoue (2021) Learning logic programs using neural networks by exploiting symbolic invariance. In Proceedings of the 30th international conference on Inductive Logic Programming, ILP-21, Lecture Notes in Computer Science, Vol. 13191, pp. 203–218. Cited by: §2. - Y. J. Phua and K. Inoue (2024) Variable assignment invariant neural networks for learning logic programs. In Proceedings of the 18th International Conference on Neural-Symbolic Learning and Reasoning, NeSy-24, Lecture Notes in Computer Science, Vol. 14979, pp. 47–61. Cited by: §1. - J. R. Quinlan (1990) Learning logical definitions from relations. Mach. Learn. 5, pp. 239–266. Cited by: §1. - L. Rokach and O. Maimon (2005) Clustering methods. In The Data Mining and Knowledge Discovery Handbook, pp. 321–352. Cited by: §3.2. - E. Sansone and R. Manhaeve (2023) Learning symbolic representations through joint generative and discriminative training. In Proceedings of the 11th International Conference on Learning Representations on Neurosymbolic Generative Models Workshops (NeSy-GeMs, ICLR-23), Cited by: §2. - E. Sansone (2023) The triad of failure modes and a possible way out. In Proceedings of the 37th Annual Conference on Neural Information Processing Systems on the 4th Workshop on Self-Supervised Learning: Theory and Practice (SSL, NeurIPS-23), Cited by: §2, §5.4. - H. Shindo, V. Pfanschilling, D. S. Dhami, and K. Kersting (2023) $\alpha$ ILP: thinking visual scenes as differentiable logic programs. Mach. Learn. 112 (5), pp. 1465–1497. Cited by: §1, §2. - S. Topan, D. Rolnick, and X. Si (2021) Techniques for symbol grounding with SATNet. In Advances in Neural Information Processing Systems 34: Annual Conference on Neural Information Processing Systems, NeurIPS-21, M. Ranzato, A. Beygelzimer, Y. N. Dauphin, P. Liang, and J. W. Vaughan (Eds.), pp. 20733–20744. Cited by: §1. - N. P. Walter, J. Fischer, and J. Vreeken (2024) Finding interpretable class-specific patterns through efficient neural search. In Proceedings of the 38th AAAI Conference on Artificial Intelligence, AAAI-24, Vol. 38, pp. 9062–9070. Cited by: §2. - B. Wang, L. Li, Y. Nakashima, and H. Nagahara (2023) Learning bottleneck concepts in image classification. In Proceedings of the 34th IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR-23, pp. 10962–10971. Cited by: §2. - H. Wang, Q. Zhang, J. Wu, S. Pan, and Y. Chen (2019) Time series feature learning with labeled and unlabeled data. Pattern Recognit. 89, pp. 55–66. Cited by: §2, §3.2, §5.2, §5.2. - J. Wang, P. Liu, M. F. She, S. Nahavandi, and A. Z. Kouzani (2013) Bag-of-words representation for biomedical time series classification. Biomed. Signal Process. Control. 8 (6), pp. 634–644. Cited by: §5.2. - Z. Xu and K. Funaya (2015) Time series analysis with graph-based semi-supervised learning. In 2015 IEEE International Conference on Data Science and Advanced Analytics, DSAA-15, pp. 1–6. Cited by: §5.2. - F. Yang, Z. Yang, and W. W. Cohen (2017) Differentiable learning of logical rules for knowledge base reasoning. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems, NIPS-17, pp. 2319–2328. Cited by: §1. - E. Zhan, J. J. Sun, A. Kennedy, Y. Yue, and S. Chaudhuri (2022) Unsupervised learning of neurosymbolic encoders. Trans. Mach. Learn. Res. 2022. Cited by: §2. - H. Zhang, I. J. Goodfellow, D. N. Metaxas, and A. Odena (2019) Self-attention generative adversarial networks. In Proceedings of the 36th International Conference on Machine Learning, ICML-19, Proceedings of Machine Learning Research, Vol. 97, pp. 7354–7363. Cited by: §5.3. ## Appendix A Ablation Study on pre-training In this section, we conduct experiments with and without pre-training the autoencoder and clustering model to investigate whether pre-training improves accuracy. The results, including accuracy and running time (in seconds), are presented in Tab. 3. Table 3: Ablation study: With vs. without pre-training autoencoder and clustering model. The first accuracy is achieved using NeurRL(N), while the second accuracy is obtained with NeurRL(R). | Coffee ECG ItalyPow.Dem. | 1.00, 0.96 0.88, 0.82 0.92, 0.93 | 42 65 63 | 0.83, 0.81 0.87, 0.64 0.75, 0.80 | 30 53 61 | | --- | --- | --- | --- | --- | | Gun Point | 0.87, 0.76 | 35 | 0.86, 0.43 | 31 | | Lighting2 | 0.75, 0.69 | 120 | 0.64, 0.60 | 63 | The experiment results indicate the pre-training autoencoder and clustering model can improve the accuracy of both NeurRL(N) and NeurRL(R) without increasing significant training time. ## Appendix B The link of the model The model and data can be found here: https://github.com/gaokun12/NeurRL ## Appendix C Classifying and Explaining MNIST data Each column in Fig. 6 corresponds to a learning task. There are six rules presented in Fig. 6 to describe the positive class from the negative class. <details> <summary>x10.png Details</summary>  ### Visual Description ## Heatmap: Digit Classification Performance Metrics ### Overview The image displays a 2x5 grid of digit classification results, comparing positive and negative class predictions. Each digit (0-9) is shown with associated performance metrics (precision [p] and recall [r]) represented by colored bars. The layout emphasizes comparative analysis between correctly and incorrectly classified digits. ### Components/Axes - **Legend**: Located in the top-left corner, mapping colors to metrics: - Red: Precision (p) - Green: Recall (r) - Blue: F1 Score (f1) - Yellow: Accuracy (acc) - **Grid Structure**: - **Rows**: - Top row: Positive Class (digits 1, 2, 4, 6, 9) - Bottom row: Negative Class (digits 0, 3, 5, 7, 8) - **Columns**: Individual digits with associated metrics - **Axis Markers**: - Digit labels (e.g., "1", "0") positioned above/below each cell - Metric labels (p, r) with values in subscript format below bars ### Detailed Analysis 1. **Positive Class (Top Row)**: - **Digit 1**: p=1.00, r=1.00 (perfect precision/recall) - **Digit 2**: p=0.99, r=0.43 (high precision, low recall) - **Digit 4**: p=0.94, r=0.31 (moderate precision, low recall) - **Digit 6**: p=0.98, r=0.89 (high precision/recall) - **Digit 9**: p=0.90, r=0.76 (moderate precision/recall) 2. **Negative Class (Bottom Row)**: - **Digit 0**: p=1.00, r=1.00 (perfect precision/recall) - **Digit 3**: p=0.99, r=0.43 (high precision, low recall) - **Digit 5**: p=0.94, r=0.31 (moderate precision, low recall) - **Digit 7**: p=0.98, r=0.89 (high precision/recall) - **Digit 8**: p=0.90, r=0.76 (moderate precision/recall) ### Key Observations - **Precision-Recall Tradeoff**: - Digits 2, 4, 3, and 5 show high precision but low recall, suggesting overconfident but incomplete classification. - Digits 6, 7, 8, and 9 demonstrate balanced performance with moderate precision/recall. - **Color Consistency**: - Red bars (precision) consistently exceed green bars (recall) for most digits, except 6 and 7 where they are nearly equal. - Yellow bars (accuracy) are absent in the image, indicating potential omission or mislabeling in the legend. - **Outliers**: - Digit 6 (positive class) and 8 (negative class) show the highest recall values (0.89 and 0.76, respectively), suggesting better sensitivity for these digits. ### Interpretation The heatmap reveals systematic performance patterns in digit classification: 1. **Model Bias**: - Digits with curved strokes (6, 9, 8) achieve higher recall, possibly due to shared feature extraction with circular shapes. - Straight-line digits (1, 2, 3, 5) prioritize precision over recall, indicating stricter classification thresholds. 2. **Confusion Matrix Implications**: - Low recall for digits 2, 4, 3, and 5 suggests these are frequently misclassified as other digits (likely 6, 8, or 9). - High precision for these digits implies that when the model predicts them, it is usually correct. 3. **Technical Limitations**: - The absence of yellow bars (accuracy) in the visualization creates ambiguity about overall model performance. - The use of p=1.00/r=1.00 for digits 1 and 0 may indicate perfect separation in training data but poor generalization. This visualization highlights the need for balanced metric optimization, particularly for underperforming digits like 2, 4, 3, and 5, where improving recall would enhance overall classification robustness. </details> Figure 6: Rules from MNIST datasets.