Temporal-Aware Chain-of-Thought Reasoning for Vibration-Based Pump Fault Diagnosis

Abstract

Industrial pump systems require real-time fault diagnosis for predictive maintenance, but conventional Chain-of-Thought (COT) reasoning faces computational bottlenecks when processing high-frequency vibration data. This paper proposes Vibration-Aware COT (VA-COT), a novel framework that integrates multi-domain feature fusion (time, frequency, time–frequency) with adaptive reasoning depth control. Key innovations involve expert prior-guided dynamic feature selection to optimize edge-device inputs, complexity-aware reasoning chains reducing computational steps by 40–65% through confidence-based early termination, and lightweight deployment on industrial ARM-based single-board computers (SBCs). Evaluated on a 12-class pump fault dataset (5400 samples from centrifugal/gear pumps), VA-COT achieves 93.2% accuracy surpassing standard COT (89.3%) and CNN–LSTM (Convolutional Neural Network-Long Short-Term Memory network) (91.2%), while cutting latency to <1.1 s and memory usage by 65%. Six-month validation at pump manufacturing facilities demonstrated 35% maintenance cost reduction and 98% faster diagnostics versus manual methods, proving its viability for IIoT (Industrial Internet of Things) deployment.

1. Introduction

Industrial pumps are foundational components of the modern economy, serving as the workhorses for fluid transport in critical sectors such as petrochemical processing, water/wastewater treatment, power-generation plants, and manufacturing facilities. The global industrial pump market, valued at tens of billions of dollars and projected to grow steadily, underscores their economic significance. However, this ubiquity comes with a significant operational challenge: unexpected pump failures. Such failures can trigger catastrophic consequences, including costly production halts, which can amount to hundreds of thousands of dollars per hour in lost revenue, and severe safety and environmental hazards. The complexity of pump failure modes—ranging from bearing wear and impeller erosion to shaft misalignment and cavitation—further complicates maintenance efforts [1]. The incipient signs of these faults are often subtle and embedded within noisy operational data, making early detection a formidable task. Consequently, industries are increasingly shifting from reactive or scheduled maintenance to predictive Maintenance (PdM) strategies, which aim to forecast failures before they occur, thereby optimizing maintenance schedules and enhancing equipment reliability [2,3]. Central to modern PdM is the use of non-intrusive condition monitoring, with vibration analysis emerging as one of the most effective techniques due to its ability to capture rich, dynamic information about the health status of rotating machinery [4].

The field of vibration-based fault diagnosis has evolved significantly over the past decades [5]. Early approaches relied heavily on signal processing techniques to extract fault-sensitive features from raw vibration data. These techniques are broadly categorized into time-domain, frequency-domain, and time–frequency domain analyses. Time-domain analysis utilizes statistical metrics, like root mean square (RMS), peak value, and kurtosis, to track changes in signal energy and impulsiveness. While computationally simple, these methods often lack the sensitivity to distinguish between different fault types, as they do not capture frequency-specific information. Frequency-domain analysis, primarily using the Fast Fourier Transform (FFT), addresses this by revealing characteristic frequencies associated with specific faults, such as bearing defect frequencies or blade pass frequencies. However, its primary limitation is its unsuitability for non-stationary signals, which are common in industrial applications with varying speeds and loads, as FFT assumes signal periodicity and loses temporal information. To overcome this, time–frequency analysis methods, like the Wavelet Transform (WT), Wavelet Packet Transform (WPT), and Empirical Mode Decomposition (EMD) were introduced, offering a simultaneous view of a signal’s temporal and spectral characteristics [6]. Despite their power in handling non-stationary signals, these methods often introduce high computational complexity and require significant expert knowledge for parameter tuning, such as the selection of an appropriate mother wavelet, which can hinder their application in real-time systems [7].

To automate the diagnostic process and reduce reliance on manual feature engineering, the research community has progressively adopted data-driven methods. This evolution began with knowledge-based expert systems in the 1980s and 1990s, which used predefined if–then rules to mimic the reasoning of a human expert. While interpretable, these systems were brittle, difficult to maintain, and struggled with knowledge acquisition bottlenecks. The 2000s saw the rise of classical machine learning models, such as Support Vector Machines (SVMs), which demonstrated strong classification performance on non-linear data but still relied on meticulously handcrafted features extracted by domain experts [8]. The current era is dominated by deep learning (DL) models, including Convolutional Neural Networks (CNNs) and Recurrent Neural Networks (RNNs), which have revolutionized fault diagnosis by enabling end-to-end learning directly from raw or minimally processed data [9]. These models can automatically learn hierarchical and discriminative features, achieving state-of-the-art accuracy [10]. However, their primary drawback is a profound lack of interpretability. DL models often function as “black boxes,” providing a diagnostic conclusion without a transparent or verifiable reasoning process. This opacity erodes trust, a critical factor in high-stakes industrial environments where maintenance decisions have significant financial and safety implications, thus creating a major barrier to the widespread adoption of otherwise powerful AI solutions [11].

This critical trade-off between the accuracy of black-box models and the need for trustworthy, explainable AI (XAI) presents a significant opportunity for innovation [12]. Recently, Chain-of-Thought (CoT) reasoning, a technique originating from the field of large language models (LLMs), has shown remarkable potential in eliciting complex, step-by-step reasoning processes [13]. CoT prompting guides a model to break down a complex problem into a sequence of intermediate, logical steps, ultimately leading to a final answer. This approach not only improves performance on complex reasoning tasks but also provides an interpretable window into the model’s decision-making process, as the generated chain of thought serves as a natural explanation. We posit that this reasoning paradigm is exceptionally well-suited for industrial fault diagnosis. The diagnostic process undertaken by a human expert—observing symptoms, forming hypotheses, and sequentially verifying evidence (e.g., checking for specific frequency harmonics after detecting a temporal impulse)—is fundamentally a chain of thought. By adapting CoT to the domain of vibration analysis, we can potentially create a system that combines the automatic feature learning power of deep learning with the transparent, step-by-step logic of an expert system, thereby bridging the gap between accuracy and interpretability.

The primary motivation for this research is to develop an intelligent fault diagnosis framework that is not only highly accurate but also transparent, efficient, and practical for deployment in real-world Industrial IoT (IIoT) environments [14]. However, adapting CoT reasoning to pump vibration data presents unique technical challenges. First, CoT was originally designed for natural language tasks, and its application to high-frequency, numerical time-series data from sensors is a non-trivial problem that requires a new way of representing and processing information. Second, a deep, multi-step reasoning process can be computationally intensive, potentially conflicting with the real-time requirements of industrial monitoring. This necessitates a mechanism for adaptive computation, where the reasoning complexity is dynamically adjusted based on the difficulty of the diagnostic task. Third, to ensure the reasoning process is robust, the model must be supplied with a comprehensive set of features that capture the full spectrum of fault characteristics. This requires an effective strategy for multi-domain feature fusion, integrating information from the time, frequency, and time–frequency domains to form a holistic view of the machine’s health [15].

To address these challenges, we propose a novel framework named Vibration-Aware Chain-of-Thought (VA-COT) for intelligent pump fault diagnosis. This paper makes the following principal contributions:

• We introduce the VA-COT framework, a new intelligent fault diagnosis architecture that, for the first time, adapts the Chain-of-Thought reasoning paradigm to interpret and diagnose faults from pump vibration signals.
• We design a multi-domain feature fusion mechanism that synergistically combines temporal, spectral, and time–frequency characteristics to provide a rich informational basis for the reasoning engine.
• We develop a novel fault-feature-guided adaptive reasoning depth control strategy. This mechanism dynamically adjusts the computational complexity of the CoT process, ensuring both high accuracy for complex faults and low latency for simple cases, making it suitable for real-time applications.
• We implement and validate an end-to-end system architecture optimized for lightweight deployment in resource-constrained IIoT environments, demonstrating its practical viability.
• We construct and will make publicly available a comprehensive, real-world pump vibration dataset encompassing 12 distinct fault categories, which serves as a robust benchmark for evaluating the proposed method and facilitating future research in the field.

2. Related Work

2.1. Evolution of Vibration-Based Fault Diagnosis Techniques

The development of pump fault diagnosis has undergone several paradigm shifts, with each generation of technology addressing the fundamental limitations of its predecessors. The expert-driven era (1980s–2000s) was dominated by rule-based systems [16]. These systems aimed to codify the diagnostic logic of human experts, such as linking vibration RMS velocity exceeding a threshold like 4.5 mm/s to specific bearing defects, achieving accuracies of 68–72% in controlled settings [17]. However, these methods relied heavily on manual interpretation of vibration features and struggled to generalize across variable operating conditions. While techniques like Statistical Process Control (SPC) introduced anomaly detection, they were less effective in handling the nonlinear vibration patterns present during transient states, such as pump startups [18].

The machine learning wave (2000s–mid-2010s) marked a shift toward data-driven diagnostics. Support Vector Machines (SVMs) became a prominent tool; for instance, research combining time-domain features with frequency harmonics on centrifugal pump datasets achieved 85.3% accuracy [19]. The primary constraints of these models were their dependence on handcrafted features, which required significant domain expertise, and their limited capacity for representing compound faults. Ensemble methods like Random Forests partially addressed these issues, demonstrating 82.7% precision in diagnosing concurrent impeller wear and misalignment, though this was still less accurate than human experts in noisy environments [20].

The ongoing deep learning revolution (mid-2010s–present) has redefined diagnostic capabilities [21]. Convolutional Neural Networks (CNNs), when applied to time–frequency images generated by methods like the Continuous Wavelet Transform (CWT), achieved breakthrough performance [22]. Wang et al, for example, attained 93.1% accuracy in detecting incipient bearing spalls (<1 mm²) using a Scalogram–CNN architecture [23]. Recurrent Neural Networks (RNNs), particularly LSTM variants, further leveraged temporal dependencies in vibration sequences [24]. A hybrid CNN–LSTM framework set a new benchmark with 95.4% accuracy across 12 fault classes, although its high computational intensity (3.8 s inference time) hindered real-time deployment [25]. While these deep learning models excel at automatically learning discriminative features and achieving state-of-the-art accuracy, their primary drawback is a profound lack of interpretability. They often function as “black boxes,” eroding the trust necessary for adoption in high-stakes industrial settings.

2.2. Interpretable AI and Chain-of-Thought Reasoning

The trade-off between the accuracy of black-box models and the need for trustworthy, Explainable AI (XAI) has created a significant opportunity for innovation. In industrial environments, where maintenance decisions carry substantial financial and safety implications, an AI’s ability to explain its reasoning is critical for building user trust and facilitating adoption.

Recently, Chain-of-Thought (CoT) reasoning, a technique originating from the field of large language models (LLMs), has shown remarkable potential in eliciting complex, step-by-step reasoning processes [26]. The core idea of CoT is to prompt a model to break down a complex problem into a sequence of intermediate, logical steps that ultimately lead to a final answer. This approach not only improves performance on complex tasks but also provides an interpretable window into the model’s decision-making process, as the generated chain of thought serves as a natural explanation. Time-domain analysis is the most direct method for vibration signal analysis, evaluating the equipment’s operational state from the perspective of signal amplitude and temporal distribution.

We posit that this reasoning paradigm is exceptionally well-suited for industrial fault diagnosis. The diagnostic process undertaken by a human expert—observing symptoms, forming hypotheses, and sequentially verifying evidence (e.g., checking for specific frequency harmonics after detecting a temporal impulse)—is fundamentally a chain of thought. While CoT has proven revolutionary in natural language processing, its application to numerical, non-stationary time-series data from machine vibrations is a novel and underexplored research avenue [27]. This paper aims to bridge that gap by adapting the CoT paradigm to create a diagnostic framework that combines the feature-learning power of deep learning with the transparent, logical reasoning of an expert system.

3. Methodology: The Temporal-Aware CoT Framework

3.1. System Architecture and Problem Formulation

The fundamental problem in industrial pump monitoring is the conversion of complex, high-frequency triaxial sensor data into clear, actionable maintenance insights. The VA–COT framework is designed as an end-to-end system that processes axial, radial, and tangential vibration streams, which are sampled at 25.6 kHz and pre-processed with a bandpass filter (0.1–8000 Hz). The system specializes in diagnosing critical failure modes, including bearing defects that generate characteristic frequency spikes, impeller faults manifesting as harmonic clusters, and shaft misalignment, which produces dominant rotational frequency components.

For each detected anomaly, the framework generates three key outputs: a fault classification (from 12 distinct fault types), a continuous severity score (ranging from 0.0 to 1.0), and a corresponding maintenance action (e.g., Monitor, Alert, Shutdown). For example, a score below 0.3 may indicate minor bearing spalling and trigger routine monitoring, while a score exceeding 0.7 signals a critical condition like severe misalignment that requires immediate intervention.

The VA-COT architecture implements a four-layer processing cascade (Figure 1):

• Data Acquisition and Preprocessing: Raw triaxial vibration data is acquired, filtered, normalized, and segmented.
• Multi-Domain Feature Extraction: Time-domain, frequency-domain, and time–frequency features are extracted in parallel to form a comprehensive representation of the machine’s health.
• Adaptive Feature Fusion: The extracted features are dynamically weighted and fused into an optimized feature vector that serves as the input for the reasoning engine.
• VA-COT Reasoning Engine: The core of the framework executes knowledge-guided inference chains with an adaptive depth mechanism to balance accuracy and efficiency, culminating in a diagnostic report.

3.2. Data Preprocessing and Multi-Domain Feature Engineering

To ensure the reliability of the diagnostic process, raw signals must undergo meticulous preprocessing before feature extraction. This workflow begins with the removal of any DC component to eliminate baseline offset. Subsequently, a band-pass filter is applied with a passband of 0.1 Hz to 10 kHz. The low cutoff frequency (0.1 Hz) removes signal drift, while the high cutoff frequency (10 kHz) suppresses random noise while preserving the high-frequency impact signals characteristic of incipient bearing faults. Finally, the filtered data is standardized and normalized to mitigate the influence of amplitude variations, ensuring stability during model training.

Following preprocessing, a multi-domain feature extraction strategy is employed to construct a holistic and robust characterization of the pump’s health status.

Time-Domain Analysis: This method quantifies a signal’s amplitude distribution and waveform morphology over time. We extract key statistical metrics, including Root Mean Square (RMS), Peak, Kurtosis, Skewness, and Crest Factor. Kurtosis, in particular, is highly sensitive to impulsive faults, like early-stage bearing pitting. The formula for kurtosis is as follows [28]:

$$K={\displaystyle \frac{\frac{1}{N}\sum _{i=1}^N(x_i-\overline{x}{)}^4}{(\frac{1}{N}\sum _{i=1}^N(x_i-\overline{x}{)}^2{)}^2}}$$

(1)

where x_i represents the discrete sample points and $\overline{x}$ is the mean. The RMS value reflects the signal’s energy, calculated as follows [29]:

$$\mathrm{R}\mathrm{M}\mathrm{S}=\sqrt{{\displaystyle \frac{1}{N}}\sum _{i=1}^N{x}_i^2}$$

(2)

where x_i is a discrete sample point and N is the total number of samples.

Frequency-Domain Analysis: Using the Fast Fourier Transform (FFT), the time-domain signal is converted into its frequency spectrum to identify characteristic frequencies associated with specific components. We focus on identifying the rotating frequency (f_r), blade pass frequency (f_bp = Z × f_r), and bearing characteristic fault frequencies (BPFI, BPFO, BSF, FTF) to diagnose issues like unbalance, impeller damage, and bearing defects.

Time–Frequency Analysis: To handle non-stationary signals common in industrial applications, time–frequency methods are used to capture how frequency components evolve over time. We utilize the following:

Continuous Wavelet Transform (CWT): This method provides multi-resolution analysis ideal for detecting transient impacts. It is defined as follows [30]:

$$W(a,b)={\displaystyle \frac{1}{\sqrt{a}}}{\int }_{-\infty }^{\infty }x(\psi )\Psi \left({\displaystyle \frac{t-b}{a}}\right)dt$$

(3)

where a is the scale factor, b is the translation factor, and ψ(t) is the mother wavelet function.

Empirical Mode Decomposition (EMD): This adaptive method decomposes a signal into a series of Intrinsic Mode Functions (IMFs), each representing a distinct oscillatory mode. The signal x(t) is represented as follows [31]:

$$x(t)=\sum _{i=1}^{n}IM{F}_i(t)+r_n(t)$$

(4)

where r_n(t) is the final residual component.

Finally, these multi-domain features are integrated using an adaptive fusion algorithm. The algorithm calculates feature importance scores to derive domain-specific weights (α, β, γ), which are then used to combine the standardized feature sets into a final, optimized fused feature vector for the VA-COT engine.

3.3. Fault Expert Prior Modeling

To overcome the “black-box” limitations of purely data-driven models and enhance interpretability, the VA-COT framework integrates a systematic model of expert domain knowledge. This model is structured into two primary components: an Intelligent Alarm Mechanism for anomaly detection and a Fault Diagnosis Model for root cause identification.

3.3.1. Intelligent Alarm Mechanism

The system employs a dual-mode alarm strategy to ensure both reliability and sensitivity.

Hard Threshold Alarms: This classic approach uses fixed “warning” and “danger” thresholds for key indicators (e.g., overall vibration values). These thresholds are set based on industry standards and historical data, providing a simple and reliable baseline for anomaly detection [32].

Intelligent Alarms: This advanced mechanism uses a comprehensive suite of fault indicators derived from time-domain, frequency-domain, and envelope spectrum analysis [33]. Instead of fixed limits, it leverages statistical regression and time-series forecasting to compute adaptive thresholds based on the equipment’s historical performance. This data-driven approach maximizes the detection rate of slowly deteriorating faults while minimizing false alarms [34]. It also grades alarms by severity and deterioration speed, helping engineers prioritize responses.

3.3.2. Fault Diagnosis Models

Upon triggering an alarm, the VA-COT engine invokes specific diagnostic models built upon an expert knowledge base. This knowledge explicitly links fault types to their characteristic vibration signatures. The diagnostic logic is organized by component, as detailed in

Table 1. Component-Specific Fault Diagnosis Models.

Component Model	Fault Diagnosis Model	Description of Covered Faults
Motor Model	Bearing Diagnosis	Damage to inner/outer race, rolling elements, cage.
	Imbalance Diagnosis	Unbalance caused by fan dust accumulation, blade wear, rotor casting voids.
	Misalignment Diagnosis	Misalignment between the motor and the driven machine.
	Looseness Diagnosis	Looseness of bearing seats, anchor bolts, end-shield distortion.
Pump Model	Bearing Diagnosis	Pump-side bearing inner/outer race spalling, roller micro-pitting.
	Imbalance Diagnosis	Impeller coking deposits, non-uniform corrosion of impeller vanes.
	Rubbing Diagnosis	Balance sleeve-drum rubbing, impeller-wear-ring contact.
	Volute/Casing Corrosion	Volute erosion-corrosion of cast-iron volute wall, casing seal-ring fretting.
Coupling Model	Misalignment Diagnosis	Shaft angular/parallel misalignment at coupling, flexible-element wear.

Data from RONDS, https://www.ronds.com/industry/scenes/general (accessed on 8 May 2025).

.

This formalized knowledge, combining if–then rules and a structured knowledge graph, provides the foundational logic for the VA-COT reasoning chains, ensuring that the diagnostic process is both accurate and interpretable [35].

3.4. VA-COT: An Interpretable Reasoning Framework

3.4.1. Adaptive Reasoning Depth Control

A key innovation of the VA-COT framework is its ability to dynamically balance diagnostic precision and computational efficiency [36]. To achieve this, we developed an Adaptive Reasoning Depth Control mechanism. This mechanism can assess online the complexity of the current vibration signal and dynamically allocate appropriate computational resources to the VA-COT engine, thereby maximizing reasoning efficiency while ensuring diagnostic accuracy.

The logical flow of this mechanism is illustrated in detail in Figure 2.

The mechanism first assesses the complexity of the input signal using a comprehensive scoring function, Scomplexity. This score integrates four key indicators [37]:

$$S_{complexity}=w_1\cdot H\left(f\right)+w_2\cdot S_{fast}+w_3\cdot N_{level}+w_4\cdot I_{compound}$$

(5)

where H(f) is the spectral entropy measuring spectral disorder, S_fault is a fault severity index, N_level is the estimated noise level, and I_compound is an indicator for the presence of multiple concurrent faults.

Based on the calculated complexity score, the system selects one of three reasoning depths:

Shallow Reasoning (e.g., score < 0.3): For clear, simple faults, a 2–3 step process is used for rapid diagnosis.

Medium Reasoning (e.g., 0.3 ≤ score < 0.7): For cases with moderate noise or minor compound faults, a 4–6 step analysis involving more advanced tools is activated.

Deep Reasoning (e.g., score ≥ 0.7): For highly complex or severe compound faults, a comprehensive analysis of 7 or more steps is invoked, integrating multi-source information and knowledge graph-based reasoning.

To further enhance efficiency, the reasoning chain itself is dynamically optimized. This includes on-the-fly feature selection based on preliminary judgments, path optimization using reinforcement learning from historical cases, and an early stopping mechanism that terminates the reasoning process once a diagnostic conclusion reaches a high confidence threshold (e.g., 95%), preventing unnecessary computation.

To ensure the effectiveness and logical integrity of the Adaptive Reasoning Depth Control mechanism, this section elaborates on its triggering mechanism, specifically the calculation of the complexity score, Scomplexity [38]. This scoring process is a critical pre-processing step designed to triage the diagnostic difficulty of a signal before committing to the formal, multi-step VA-COT reasoning chain.

Crucially, it must be clarified that the indicators used in Equation (5) are all fast, preliminary estimations derived using computationally inexpensive heuristics. Their sole purpose is to select an appropriate reasoning path, not to serve as the final diagnostic output, thereby resolving any suspicion of circular reasoning. The rapid estimation methods for each indicator are as follows:

Fault Severity Index (Sfault): This is a heuristic preliminary index, not the final precise score. It is rapidly estimated by comparing the overall energy (RMS value) of the current vibration signal to a historical baseline established during the equipment’s healthy operation. For instance, a signal with energy 50% above its baseline will yield a significantly higher preliminary severity index than one that is 10% above.

Spectral Entropy (H(f)): This metric is directly calculated from the Fast Fourier Transform (FFT) spectrum, which is already generated during the preprocessing stage, to measure spectral disorder. It is a standard and computationally cheap calculation.

Noise Level (Nlevel): The noise level is estimated by analyzing the signal’s spectral floor or the average energy in non-dominant frequency bands. This serves as a quick proxy for the signal-to-noise ratio.

Compound Fault Indicator (Icompound): This indicator is estimated via a fast spectral analysis algorithm that identifies and counts the number of independent, prominent harmonic families present in the spectrum (e.g., a rotational frequency harmonic family, a specific bearing fault frequency harmonic family, etc.). The presence of multiple independent harmonic families is a strong indicator of a more complex compound fault.

Regarding the weights (w1, w2, w3, w4) in Equation (5), they are not set empirically. Instead, they are treated as critical hyperparameters and are determined through a rigorous optimization process. Using a validation subset of our benchmark dataset, a Grid Search methodology was employed to systematically test various weight combinations [39]. The objective function for evaluating each combination was a weighted balance between diagnostic accuracy (F1-Score) and average inference latency. The set of weights that yielded the optimal performance on this objective function was ultimately selected, ensuring that the mechanism allocates computational resources most effectively while maintaining high diagnostic precision [40].

Through this two-stage strategy—a rapid preliminary assessment followed by a selected-depth reasoning—the VA-COT framework can effectively adapt its behavior to the task’s difficulty, resolving the potential for circular logic and achieving a balance between diagnostic accuracy and computational efficiency.

3.4.2. The VA-COT Hybrid Reasoning Engine: Concepts and Mechanisms

To address the challenge of applying Chain-of-Thought (CoT) reasoning to numerical vibration data, the VA-COT engine is designed not as a natural language generator, but as a knowledge-guided hybrid reasoning engine. It operationalizes the diagnostic process of a human expert by creating a sequence of structured, verifiable steps [41]. The “chain of thought” is an internal, structured data representation, not a textual output from the core engine [42]. This hybrid approach synergizes a rule-based knowledge base for interpretability with a lightweight neural network for data-driven accuracy [43].

A.

The Structured Thought Node

The fundamental unit of the reasoning chain is the “Thought Node,” a structured object that captures the state of a single diagnostic step. The entire chain is a chronologically ordered list of these nodes. Each node is defined as follows:

ThoughtNode = {

step_id: Integer,

//The sequence number of the step (e.g., 1, 2, 3).

current_hypothesis: String,

//The primary hypothesis being tested in this step (e.g., “Investigating potential bearing fault”).

supporting_evidence: Dict,

//Quantitative evidence from the feature vector supporting the hypothesis (e.g., {“Kurtosis”: 4.5, “BPFO_Amplitude”: 0.8}).

confidence_score: Float,

//The calculated confidence (0.0 to 1.0) in the current hypothesis.

status: Enum

//The outcome of the investigation for this node: [“Confirmed”, “Rejected”, “Requires_Further_Analysis”].

}

```

This structure transforms the abstract CoT concept into a concrete computational entity, allowing the diagnostic path to be explicitly tracked and audited.

B.

The Iterative Reasoning Process

The VA-COT engine constructs the chain of Thought Nodes through a Hypothesis–Verification–Iteration loop, which begins after the complexity score $S\_{complexity}$ has determined the required reasoning depth (Shallow, Medium, or Deep).

• Initiation (Step 0: Anomaly Detection): The process starts with the fused multi-domain feature vector. The engine first checks macro-level health indicators (e.g., overall RMS, Peak value). If these indicators breach the baseline established by the intelligent alarm mechanism (Section 3.3.1), the first node, `ThoughtNode_0`, is generated with the hypothesis “Anomaly Detected.”
• Hypothesis Generation and Selection (The Hybrid Core): For each subsequent step, the engine generates and selects a new hypothesis using its hybrid core. This process is detailed further in the following section.
• Evidence Focusing and Confidence Update: Once a hypothesis is selected, the engine focuses its analysis on the most relevant features from the input vector. This targeted evidence is used to calculate a new confidence_score for the hypothesis.
• Iteration and Termination: The engine evaluates the confidence_score. If it exceeds the predefined threshold (e.g., 95%), the hypothesis is marked as “Confirmed,” and the reasoning chain may terminate early to prevent unnecessary computation. If the confidence is low, the loop continues to the next step until the maximum depth is reached or a conclusion is found.

To ensure the auditability and reproducibility of the reasoning process, the components of the hybrid engine are precisely defined. Our knowledge base consists of 92 rules derived from domain expertise and maintenance manuals, covering the primary failure modes of the target equipment. In cases where multiple rules are triggered simultaneously by the evidence from a ThoughtNode, all resulting candidate hypotheses are passed to the Hypothesis Scorer. This neural network thus acts as the conflict resolution mechanism, using data-driven evidence to arbitrate between competing, rule-based suggestions. The Hypothesis Scorer itself is a lightweight Multi-Layer Perceptron (MLP) with two hidden layers (64 and 32 neurons, respectively) using ReLU activation functions, optimized for high-speed inference on edge devices. Further details on the reasoning engine’s specifications are provided in Appendix C.

C.

Connecting the Reasoning Steps: The Decision and Transition Mechanism

The transition from one reasoning step (N) to the next (N + 1) is a structured process that ensures the diagnostic path is logical and efficient. This mechanism directly answers how the output of one step informs the input for the next.

Let us use an example: after the engine confirms an “impact in the time domain” (ThoughtNode_N), it “decides” to check for “specific frequency harmonics” in ThoughtNode_N + 1 as follows:

• Knowledge-Guided Interrogation Targeting: The confirmed hypothesis from ThoughtNode_N (e.g., “Impulsive Fault Signature Detected”) is used to query the expert knowledge base. The knowledge base contains explicit mappings between fault signatures and subsequent analytical procedures. A rule such as IF signature IS “Impulsive” THEN next_target IS “Analyze_Frequency_Spectrum_for_Harmonics” dictates the next logical action. This provides a transparent, rule-based justification for the transition.
• Scoping the Hypothesis Space: The determined next_target (“Analyze_Frequency_Spectrum”) is then used to constrain the search space for the next set of hypotheses. The engine queries the knowledge base again with this new context (e.g., GIVEN context IS “Impulsive_Fault” AND target IS “Analyze_Spectrum”, retrieve plausible root_causes). This results in a refined, focused list of candidates, such as [“Outer Race Defect (BPFO)”, “Inner Race Defect (BPFI)”, “Rolling Element Defect (BSF)”], preventing the consideration of irrelevant faults.
• Data-Driven Selection: Finally, the lightweight neural “Hypothesis Scorer” takes this refined list of candidates and the full feature vector as input. Guided by the interrogation target, it prioritizes the frequency-domain features and assigns a relevance score to each candidate. The hypothesis with the highest score (e.g., “Outer Race Bearing Defect,” if a strong BPFO signal is present) is selected as the current_hypothesis for ThoughtNode_N + 1.

This structured transition ensures the entire Chain-of-Thought proceeds in a manner that is both mechanistically sound and interpretable to a human expert.

D.

Final Report Generation

The output of the core VA-COT engine is the final, structured list of Thought Nodes. This list is then passed to a separate, post-processing “Report Generation Module.” This module uses a template-based system to translate the structured findings into the human-readable diagnostic text, such as that presented in the industrial case study. For example, a confirmed ThoughtNode with hypothesis = “rubbing characteristics” and evidence pointing to the “free-end bearing” is mapped to the corresponding sentence in a predefined report template. This decouples the core numerical reasoning from complex natural language generation, ensuring efficiency and reliability.

3.4.3. Execution of the Reasoning Chain: An Algorithmic View

To provide an unambiguous and transparent view of the VA-COT engine’s internal workflow, the conceptual mechanisms described in the previous sections are formalized in Algorithm 1. This pseudocode illustrates the end-to-end process, from receiving the fused feature vector to outputting a final diagnostic report. It integrates the adaptive depth control, the iterative hybrid reasoning loop, and the final report generation into a single, cohesive algorithm.

Algorithm 1: The VA-COT Diagnostic Process

Function VA_COT_Diagnose(Input: fused_feature_vector)

//Phase 1: Adaptive Depth Selection

complexity_score = Calculate_Complexity_Score(fused_feature_vector)

max_depth = Select_Max_Depth(complexity_score)

//Phase 2: Initialization of the Reasoning Chain

reasoning_chain = new List<ThoughtNode>()

initial_node = Create_Initial_Node(fused_feature_vector)//e.g., Hypothesis: “Anomaly Detected”

reasoning_chain.add(initial_node)

//Phase 3: Iterative Reasoning Loop

for step from 1 to max_depth:

`last_confirmed_node = reasoning_chain.get_last_confirmed()`

//**Knowledge-guided hypothesis proposal using expert prior** [cite: 175]

`candidate_hypotheses = Propose_Hypotheses(knowledge_base, last_confirmed_node)` [cite: 186, 189]

//**Data-driven hypothesis selection**

`selected_hypothesis = Score_and_Select_Hypothesis(neural_scorer, fused_feature_vector, candidate_hypotheses)`

//**Evidence gathering and confidence update**

`evidence, confidence = Gather_Evidence(fused_feature_vector, selected_hypothesis)`

//**Create and add the new node to the chain**

`new_node = new ThoughtNode(step, selected_hypothesis, evidence, confidence)`

`reasoning_chain.add(new_node)`

//**Check for early stopping based on confidence threshold** [cite: 235]

**if** `confidence > CONFIDENCE_THRESHOLD`:

`new_node.status = “Confirmed”`

**break**//Exit loop if conclusion is confident

**end if**

end for

//Phase 4: Final Report Generation

diagnostic_report = Generate_Report_From_Chain(template_module, reasoning_chain)//Generates Fault Type, Severity Score, and Maintenance Action

Return diagnostic_report

End Function

4. Experiment Setup and Evaluation

4.1. Experimental Platform and Datasets

4.1.1. Benchmark Dataset

To evaluate the core performance of the VA-COT framework in a controlled environment, a comprehensive benchmark dataset was utilized. This dataset comprises 5400 labeled vibration samples collected from both centrifugal and gear pumps, encompassing 12 distinct fault categories. A detailed description of the equipment, operating parameters, data acquisition system, and a full list of all 12 fault categories are provided in Appendix A.

4.1.2. Industrial Validation Platform

For real-world validation, the VA-COT framework was deployed on a commercial-grade remote O&M cloud platform, with the edge-side processing handled by an industrial single-board computer (SBC) featuring an ARM Cortex-A72 processor with 1 GB of RAM [44]. This hardware was chosen to reflect typical processing capabilities available in modern IIoT gateways. While optimization techniques such as INT8 quantization with frameworks like CMSIS-NN were evaluated, the reported performance results utilize the full-precision (FP32) model to ensure maximum diagnostic accuracy, as the available memory was sufficient. A detailed breakdown of the on-device memory footprint is provided in Appendix E.

4.2. Baseline Models and Evaluation Metrics

To benchmark the performance of the proposed VA-COT framework, we compared it against several baseline models:

Standard CoT: A version of the Chain-of-Thought model without the temporal-aware adaptations.

CNN–LSTM: A state-of-the-art deep learning model commonly used for time-series classification, which can automatically learn features from raw or minimally processed data.

Support Vector Machine (SVM): A classic and powerful machine learning model often used in fault diagnosis, trained on the same fused feature set as VA-COT.

PatchTST [X]: A state-of-the-art, Transformer-based model for time-series forecasting and classification, representing modern attention-based architectures.

TinyVGG-T: An edge-optimized Convolutional Neural Network, adapted for spectral analysis, representing lightweight deep learning solutions designed for efficiency.

Performance was evaluated using standard classification metrics, including Accuracy, Precision, Recall, and F1-Score. To assess the framework’s suitability for real-time industrial deployment, we also measured average Inference Latency and Memory Usage on the target edge device. The trade-off between accuracy and latency is visualized using a Pareto front analysis.

5. Results

5.1. Performance on Benchmark Dataset

The VA-COT framework was rigorously evaluated on the comprehensive 12-class benchmark dataset. As detailed in

Table 2. Performance Comparison with Baseline Models.

Model	Accuracy (%) *	F1-Score (%) *	Avg. Latency (s) *	Memory Usage (MB) *
VA-COT	93.2 (±1.1)	92.9 (±1.0)	1.08 (±0.05)	4.4 (±0.1)
Standard COT	89.3 (±1.4)	88.5 (±1.5)	1.32 (±0.06)	4.8 (±0.1)
PatchTST	93.5 (±1.0)	93.1 (±1.1)	4.52 (±0.21)	15.0 (±0.4)
CNN–LSTM	91.2 (±1.3)	90.6 (±1.2)	3.81 (±0.15)	12.5 (±0.3)
TinyVGG-T	90.5 (±1.5)	89.9 (±1.6)	0.61 (±0.04)	2.8 (±0.1)
SVM	88.1 (±1.7)	87.7 (±1.8)	0.45 (±0.03)	3.5 (±0.1)

* Values in parentheses indicate the 95% Confidence Interval (CI) calculated via a 1000-repetition paired bootstrap. Performance metrics were measured on the target edge device.

, the framework achieved a superior overall accuracy of 93.2% and an F1-Score of 92.9%. This performance significantly surpasses that of established baseline models, including the state-of-the-art CNN–LSTM (91.2% accuracy, 90.6% F1-Score) and a classic SVM model (88.1% accuracy, 87.7% F1-Score).

An ablation study (

Table 3. Ablation Study of the VA-COT Framework.

Model Configuration	Accuracy (%)	F1-Score (%)	Latency (s)
VA-COT (Full Model)	93.2	92.9	1.05
VA-COT w/o Adaptive Reasoning	92.5	92.1	2.85
VA-COT w/o Multi-Domain Fusion	90.7	90.1	1.09
VA-COT w/o expert prior	91.5	90.9	1.12

) confirmed the critical contributions of the framework’s core components. Removing the multi-domain feature fusion module led to a notable drop in accuracy, underscoring the importance of a holistic feature set. Similarly, disabling the adaptive reasoning mechanism resulted in a nearly threefold increase in latency (from 1.05 s to 2.85 s) with only a marginal gain in accuracy, validating its effectiveness in optimizing computational resources.

The accuracy–latency trade-off, visualized in the Pareto curve in Figure 3, further illustrates VA-COT’s practical superiority for edge deployment. While models like PatchTST achieve a slightly higher F1-Score (93.1%), their inference latency is over four times greater (4.52 s). Conversely, faster models like TinyVGG-T and SVM sacrifice significant diagnostic accuracy. VA-COT is positioned at the optimal point on the Pareto front, delivering high accuracy with an average latency of just 1.08 s on the target edge device, making it the most balanced solution for real-world industrial applications.

5.2. Industrial Validation and Practical Utility

To validate its real-world efficacy, the VA-COT framework was deployed for six months at the Huafeng Thermoelectric facility. The system demonstrated significant operational value, contributing to a 35% reduction in maintenance costs and accelerating diagnostic processes by 98% compared to manual methods.

A compelling case study involved a critical boiler feedwater pump. The VA-COT system automatically flagged the pump with a “Warning” status and generated a detailed, interpretable diagnostic conclusion: “1. Rubbing characteristics are present at the pump’s free end, which is presumed to be related to bearing damage… 2. Pitting damage and potential minor spalling exist on the inner race of the free-end bearing…”. This AI-driven recommendation prompted a scheduled inspection. Subsequent physical teardown confirmed the diagnosis, revealing “severe wear on the end face between the balance sleeve and the balance drum” and “deep wear marks on the inner surface of the casing seal ring,” which directly corresponded to the identified rubbing and bearing damage. This successful closed-loop validation—from automated online diagnosis to confirmed physical evidence—powerfully demonstrates the framework’s accuracy and practical value in a complex industrial setting.

The framework’s robustness and efficiency were further substantiated by the following:

Cross-Machine Generalization: In a zero-shot transfer task, the model, trained only on centrifugal and gear pump data, retained a high Macro-F1 score of 86.3% when applied to an unseen dataset from industrial screw pumps, demonstrating strong foundational generalization capabilities (Appendix D,

Table A2. Zero-Shot, Cross-Model Transfer Performance.

Test Set.	Macro-F1 Score.
In-Domain (Centrifugal/Gear Pumps).	92.90%.
Out-of-Domain (Screw Pumps).	86.30%.
Performance Drop.	−6.60%.

).

Edge Deployment Efficiency: Operating on a resource-constrained ARM Cortex-A72 based single-board computer, the VA-COT framework maintained a minimal memory footprint of just 4.4 MB, confirming its suitability for widespread deployment in IIoT edge computing environments (Appendix E,

Table A3. Detailed Memory Footprint of VA-COT on Edge Device.

Component.	Memory Usage (MB).	Description.
Neural Scorer Weights (FP32).	0.5 MB.	The memory required to load the lightweight MLP model.
Knowledge Base (JSON Rules).	0.2 MB.	The memory footprint of the loaded rule set for hypothesis generation.
Feature Extraction and Processing.	2.5 MB.	Memory allocated for raw signal segments, FFT, CWT, and other feature arrays.
VA-COT Engine Inference Cache.	1.2 MB.	Runtime cache for storing the ThoughtNode chain and intermediate states.
Total.	4.4 MB.	Total dynamic memory (RAM) usage during inference.

).

5.3. Quantitative Evaluation of Explainability

To objectively measure the framework’s interpretability, we conducted a two-pronged evaluation protocol, moving beyond qualitative assessment.

Automated Faithfulness Analysis: We measured how accurately the generated “thought” steps reflected the model’s internal decision-making. By systematically perturbing key features cited as evidence in the reasoning chain, we observed a corresponding drop in the model’s output confidence. The results yielded a high average Faithfulness Score of 0.89 (±0.06), indicating a strong correlation between the explanation provided and the model’s internal logic (

Table 4. Quantitative Explainability Evaluation Results.

Metric	Score/Value
Automated Metric
Avg. Faithfulness Score	0.89 (±0.06)
Human Evaluation (n = 30, 3 raters)
Avg. Correctness (1–5 scale)	4.6 (±0.4)
Avg. Completeness (1–5 scale)	4.4 (±0.5)
Avg. Clarity (1–5 scale)	4.7 (±0.3)
Avg. Actionability (1–5 scale)	4.5 (±0.4)
Inter-rater Reliability (ICC)	0.86
Correlation Significance (t-test p-value)	<0.01

).

Human-Centered Blind Study: Three independent domain experts, blind to the model’s predictions, evaluated the reasoning chains for 30 randomly selected cases. The explanations received high average scores for technical Correctness (4.6/5) and Clarity (4.7/5), with strong inter-rater reliability (ICC of 0.86). A statistically significant positive correlation (p < 0.01) was found between the model’s confidence and the experts’ correctness ratings, confirming that the framework’s reasoning aligns with human diagnostic logic.

These quantitative results confirm that VA-COT successfully balances high diagnostic accuracy with transparent, trustworthy, and actionable insights, directly addressing the critical interpretability gap in conventional “black-box” AI systems. Visual examples of the step-by-step diagnostic reasoning chains for healthy, simple, and complex fault signals are provided in Appendix B.

6. Discussion

6.1. Interpretation of Key Findings

The experimental results robustly demonstrate that the VA-COT framework’s superior performance stems from its unique synthesis of data-driven feature representation and knowledge-guided reasoning. Unlike purely data-driven models like CNN–LSTM that learn opaque correlations, VA-COT leverages a structured expert knowledge base to guide its diagnostic process, effectively mimicking an expert’s logical flow. This synergy allows it not only to identify anomalies but also to interpret their context, leading to higher diagnostic accuracy, as evidenced by its 93.2% accuracy on the 12-class benchmark dataset (Table 3). The ablation study further validates this, showing that removing the multi-domain feature fusion module leads to a significant drop in accuracy, confirming the necessity of a comprehensive feature set for robust diagnosis (Table 3).

The framework’s efficiency gains are primarily explained by its adaptive reasoning depth control. This mechanism dynamically allocates computational resources based on signal complexity, achieving real-time performance on edge devices without sacrificing the depth of analysis required for complex faults. The ablation study highlights this trade-off: disabling this mechanism nearly triples the inference latency (from 1.05 s to 2.85 s) for only a marginal accuracy improvement (Table 3). This efficiency is not merely an academic benefit but a critical requirement for scalable deployment. The accuracy–latency Pareto curve (Figure 3) clearly positions VA-COT as the optimal solution for edge computing, delivering high accuracy at a fraction of the computational cost of powerful but slow models, like PatchTST. However, the 86.3% Macro-F1 score observed in the zero-shot cross-machine generalization experiment (Appendix D, Table A2) suggests that, while the foundational reasoning is robust, the expert priors may still require tuning for novel equipment types not seen during training.

6.2. The Significance of Interpretability in Industrial Practice

A core contribution of this work lies in bridging the critical gap between AI-driven diagnostics and operational trust. The chain of thought generated by VA-COT provides a transparent, step-by-step explanation for its conclusions, which is a stark contrast to the opaque outputs of typical deep learning models. This was powerfully demonstrated in the Huafeng Thermoelectric case study. The system’s output was not a simple label like “Fault Class 11,” but a logical narrative: “1. Rubbing characteristics are present at the pump’s free end… 2. Pitting damage and potential minor spalling exist on the inner race of the free-end bearing…”.

This transparent reasoning process is what builds confidence and empowers plant engineers to make informed, high-stakes decisions, such as scheduling a costly but necessary maintenance intervention. The subsequent physical teardown, which confirmed the AI’s findings, provides a closed-loop validation of this trust. This transforms the AI from a “black-box” tool into a trustworthy collaborative partner, a crucial step for its adoption in safety-critical industrial environments. The quantitative evaluation of explainability further substantiates this, with the framework achieving a high average Faithfulness Score of 0.89 and receiving excellent ratings from domain experts on Correctness (4.6/5) and Clarity (4.7/5) (Table 4). This alignment with human diagnostic logic is directly linked to practical benefits, such as the 35% reduction in maintenance costs observed during the industrial validation.

6.3. Limitations and Future Work

Despite its promising results, this study has several limitations that open clear avenues for future research.

First, the performance of the VA-COT framework is partly dependent on the comprehensiveness of its initial expert prior base. The creation of this knowledge base can be labor-intensive and requires significant domain expertise. Future work will explore the use of Large Language Models (LLMs) to semi-automatically mine maintenance logs and technical manuals to automate and expand this knowledge base. To ensure the knowledge base remains a dynamic and evolving asset, a life-cycle management approach is necessary, incorporating continuous validation against field maintenance reports and a modular architecture for efficient updates.

Second, while the framework was validated in a real-world setting, its generalization capability requires further investigation, as highlighted by the 6.6% performance drop in the zero-shot transfer experiment. To enhance stability across diverse equipment and operating conditions, future work must integrate Deep Transfer Learning (DTL) methodologies. This would involve strategies such as model fine-tuning or domain adaptation to adapt the framework to new machine types with minimal labeled data, thereby improving its robustness.

Third, the current evaluation relies on standard machine learning metrics (e.g., accuracy, F1-score), which do not fully capture the framework’s real-world value. A crucial next step is to conduct a longitudinal field study to evaluate the system using maintenance-centric KPIs. This would involve quantifying its economic and operational impact by measuring metrics such as the average lead-time of early warnings, the impact of false-alarm rates on maintenance costs, and the overall reduction in unplanned downtime and associated expenses.

Fourth, the long-term reliability of the framework necessitates a more comprehensive robustness evaluation. The current pre-processing is described simply as a band-pass filter, without validation under adverse conditions. Future work must include rigorous stress tests to substantiate the framework’s reliability in long-term industrial use. This evaluation should simulate real-world data imperfections, including performance under systematic SNR (Signal-to-Noise Ratio) degradation, resilience to sensor drift, and stability against changes in the machine’s baseline signature due to hardware aging.

Finally, looking beyond diagnostics, a logical and high-value extension is to adapt the chain-of-thought reasoning for prognosis, specifically enabling the prediction of Remaining Useful Life (RUL). This future work will focus on developing models that output probabilistic RUL forecasts with confidence intervals. Such outputs are designed to directly interface with Enterprise Resource Planning (ERP) systems, enabling the automation of procurement of parts and the optimization of maintenance scheduling, thus providing a complete, strategic solution for predictive maintenance.

7. Conclusions

This paper introduced the Vibration-Aware Chain-of-Thought (VA-COT) framework, a novel approach for intelligent pump fault diagnosis that prioritizes both accuracy and interpretability. By integrating multi-domain feature fusion with a knowledge-guided, adaptive reasoning engine, VA-COT effectively addresses the “black-box” problem inherent in many conventional deep learning models.

Our extensive experiments demonstrated the superiority of the VA-COT framework. On a 12-class benchmark dataset, it achieved 93.2% accuracy, outperforming standard CoT and CNN–LSTM models while drastically reducing latency and memory usage. More significantly, its practical efficacy was validated through a six-month deployment in an industrial setting, highlighted by a case study where an online automated diagnosis was subsequently confirmed by physical teardown inspection.

By successfully adapting the Chain-of-Thought paradigm for complex, temporal vibration data, this work provides a robust and trustworthy solution for real-world predictive maintenance. The VA-COT framework represents a significant step toward creating more transparent, reliable, and collaborative AI systems for critical industrial applications, fostering greater confidence in the adoption of Industry 4.0 technologies.