Sensorless Collision Detection and Classification in Collaborative Robots Using Stacked GRU Networks

Abstract

The increasing deployment of collaborative robots in industrial manufacturing environments has enabled close human–robot collaboration, making rapid and reliable collision detection essential for worker safety. This paper presents a learning-based framework for real-time detection and classification of hard and soft collisions using stacked Gated Recurrent Unit (GRU) networks. A two-stage pipeline is introduced, in which collision detection and collision type classification are performed sequentially using separate models, and its performance is validated through extensive experiments on a collision dataset collected from a six-joint collaborative robot executing random point-to-point motions. Without requiring joint torque sensors, unmodeled joint friction is implicitly compensated through learning for both detection and classification. Compared to our previous work, the proposed method achieves improved detection performance, and its robustness is further demonstrated through systematic generalization experiments under simulated dynamic model uncertainties. In addition, the classification model accurately distinguishes between hard and soft collisions, providing a basis for differentiated post-collision reaction strategies. Overall, the proposed sensorless collision detection and classification framework provides a practical and cost-effective solution for real-world industrial human–robot collaboration.

1. Introduction

Industrial manufacturing environments are changing rapidly with the increasing deployment of collaborative robots, enabling effective human–robot collaboration. Unlike traditional industrial robots that operate in strict separation from humans, collaborative robots are designed to share the same workspace and interact with human workers—both physically and non-physically—through various forms of human–robot interaction [1,2,3].

These changes have enabled more flexible and adaptive production processes, but worker safety must be rigorously addressed; minimizing worker injury risk while maintaining production efficiency is essential for adopting collaborative robots. Because collaborative robots operate in shared workspaces with human workers, physical contact—whether intentional or accidental—is inevitable, increasing the likelihood of unexpected collisions. Rapid detection, accurate classification, and appropriate reaction to collisions are therefore critical for reducing the risk of human injury, minimizing production downtime, and preventing secondary damage.

Collision detection methods can be generally categorized into two approaches based on their reliance on the robot’s dynamic model: model-free and model-based. Model-free methods typically require external sensors such as tactile surface sensors [4,5,6] or three-axis accelerometers [7,8,9] attached to the robot (thereby increasing system complexity and cost). While tactile surface sensors offer high sensitivity for detecting and localizing collisions, their practical implementation poses significant challenges. These sensors must be installed across the entire robot surface to ensure full coverage, and they often degrade under repeated impacts, making them unreliable for long-term industrial use. Three-axis accelerometers can effectively detect hard collisions characterized by sharp impacts, but they exhibit fundamental limitations in detecting soft collisions involving gradually increasing forces, such as pushing or clamping.

Due to these limitations, model-based methods are more widely adopted and are generally regarded as the standard in practice [10,11,12,13,14]. These approaches utilize joint torque measurements in conjunction with an accurate robot dynamic model. The underlying principle is to compute the external joint torque ${\tau }_{ext}$ induced by collision forces and compare it against a set of threshold values predetermined for each joint to determine whether a collision has occurred. While joint torque can be directly measured using joint torque sensors, many collaborative robots are not equipped with them due to their high cost, and installing such sensors afterward is in many cases impractical. Consequently, joint torque is often estimated using motor current sensors, which are already integrated into standard robotic systems. The most well-known and widely used model-based method for estimating external torque from motor current is the momentum observer (MOB) [10,15]. This method offers significant advantages, including eliminating the need for external sensors and providing consistent estimation sensitivity regardless of the robot’s configuration.

However, as noted above, the MOB approach requires accurate knowledge of the robot’s dynamic model parameters. This requirement presents substantial practical challenges, particularly in modeling joint frictional torque ${\tau }_F$, which is difficult due to its nonlinear characteristics and its sensitivity to payload variations and temperature changes. Even when friction is carefully identified using sophisticated modeling techniques, numerous unmodeled dynamic effects (e.g., elasticity, backlash) remain problematic. Furthermore, setting detection thresholds for each joint (i.e., using multiple thresholds) makes adjusting detection sensitivity cumbersome and unintuitive.

In response to these modeling challenges, recent research has explored learning-based methods for collision detection. Rather than explicitly modeling joint friction and other complex dynamic effects, these approaches train neural networks using actual collision data collected from robot operations. Heo et al. [16] employed a one-dimensional convolutional neural network (1-D CNN) that takes 11 inputs per joint, including joint position, velocity, position error, velocity error, and estimated external torque, to detect collisions. Their method outputs a binary collision index, thereby eliminating the need for detection thresholds, but its validation was limited to repetitive motion cycles, which restricts its generalizability to diverse robot motions. Sharkawy et al. [17] proposed a neural network that estimates ${\tau }_{ext}$ for each joint without requiring the dynamic model, using joint position error and velocity as inputs. Collision detection was then performed by comparing the estimated external torque with predefined thresholds. Their experiments assumed planar horizontal motions in which gravitational effects could be neglected, restricting the practical applicability of the method. In another study [18], the authors extended their method to spatial motions by utilizing joint torque sensors. While this approach operates in three-dimensional space with joints moving from $-{90}^{\circ }$ to ${90}^{\circ }$, the experiments were still conducted under limited three-joint motions. A common limitation of these early studies [16,17,18] is that they were evaluated only on a narrow range of robot motions, making them impractical for real industrial use where complex, high-degree-of-freedom motions are routine.

Recent approaches (including our previous works) have focused on compensating for dynamic model errors and friction modeling through deep learning, enabling collision detection during general robot operations including random motions. Lim et al. [19] proposed a residual learning method based on a long short-term memory (LSTM) network that models the uncertainty in MOB outputs, including friction and dynamic modeling error, allowing for the estimation of pure external torque without relying on an accurate dynamic model. Their method was demonstrated under random motions using a two-joint vertical test platform. The authors also introduced a modularized neural network that takes joint measurements including MOB output and joint velocity as inputs to predict the binary collision index [20]. Joint velocity was included so that the network could internally learn the nonlinear joint friction. While they conducted extensive experiments on dataset size, input feature combinations, and transfer learning, the method exhibits performance degradation when the payload reaches 5 kg, producing false alarms. Zhang et al. [21] employed a backpropagation neural network trained with joint position, velocity, acceleration, and motor current as inputs to improve external torque estimation accuracy in the presence of dynamic model uncertainties, with validation performed on a single-joint test platform. Niu et al. [22] applied continuous wavelet transform to joint measurements to generate multiple time–frequency representations, which were then used as inputs to a CNN with a sigmoid output layer to estimate collision probability. The proposed model can be trained with limited collision data and generalizes well to random robot motions. Collision detection was demonstrated under hard collisions applied to a manipulator composed of two variable stiffness actuators.

In our previous works [23,24], we developed learning-based collision detection methods that use ${\tau }_{ext}-{\tau }_F$ (i.e., estimated external joint torque contaminated by unmodeled friction) captured over a sliding time window as network input. In [23], supervised learning methods—a support vector machine (SVM) and a 1-D CNN—were trained using both collision and collision-free data, whereas in [24], unsupervised anomaly detection algorithms—a one-class SVM and an autoencoder—were employed as an alternative approach that eliminates the need for collision data during training, albeit with a slight reduction in detection performance. All methods detected a wide range of hard and soft collisions with high accuracy during random six-joint motions, effectively compensating for the unmodeled friction.

However, several limitations remained, leaving room for further improvement. First, even for the supervised methods that showed better detection performance, the methods failed to detect one or two collisions when false positives (false alarms) were suppressed to zero. In addition, a lower detection delay (the elapsed time from collision onset to detection) is always preferred. Second, for learning-based methods, generalization to unseen situations is an important factor to consider. Although our previous models successfully generalized to various robot motions, we did not explicitly investigate their robustness to small perturbations in the dynamic parameters (i.e., model uncertainties). Finally, our previous studies did not distinguish between hard and soft collisions (i.e., classify collision types). Collision classification would enable the robot to execute appropriate reactions depending on the collision type. For example, in the case of a hard collision, the robot could immediately stop to prevent secondary damage, whereas in a soft collision such as clamping, it could switch to a compliant mode, allowing the worker to safely push the robot away.

In this paper, we present an improved learning-based framework for real-time detection and classification of hard and soft collisions in collaborative robots, employing stacked Gated Recurrent Unit (GRU) networks. A two-stage pipeline is introduced, in which collision detection and collision classification are executed sequentially using separate models, each augmented with an output filter. The detection and classification performance is validated through extensive experiments on a collision dataset collected from a six-joint collaborative robot executing random point-to-point motions under three different payload conditions. The technical contributions of the proposed method are summarized as follows:

1.

Without requiring additional sensors such as joint torque sensors, unmodeled joint friction is implicitly compensated through learning for both collision detection and classification.

2.

The proposed detection model achieves improved performance in terms of detection speed and reliability compared to the previously developed 1-D CNN-based method, with particularly notable improvements for soft collisions.

3.

The robustness of the detection model is further validated through systematic generalization experiments under simulated dynamic model uncertainties, demonstrating its suitability for practical deployment under uncertain operating conditions.

4.

The proposed classification model accurately distinguishes between hard and soft collisions, and the effect of the output filter parameter on classification performance is systematically analyzed.

The proposed method relies on internal proprioceptive sensing (commonly referred to as sensorless approaches in the literature [15,25,26]), where motor current measurements inherently available in the robot are used to estimate external joint torque via an MOB. Here, sensorless indicates that no additional external sensors (e.g., force/torque sensors, tactile sensors, or accelerometers) are required.

The remainder of this paper is organized as follows. Section 2 describes the robot collision dataset, including MOB formulation and collision scenarios. Section 3 provides details of the proposed learning-based method for collision detection and classification, and its performance is evaluated and discussed in Section 4. Finally, Section 5 concludes the paper.

2. Robot Collision Data

2.1. Robot Platform

The robot collision data used in this study were collected in our previous work [23] using a six-joint collaborative robot, M0609 (Doosan Robotics), designed for safe human–robot interaction in industrial environments where unintended collisions with humans or surrounding structures may occur. Owing to its specifications—six joints, 6 kg payload capacity, and 0.1 mm repeatability—this robot provides a representative platform for evaluating collision detection and classification methods under conditions comparable to real industrial applications.

2.2. Monitoring Signal

The monitoring signal used as the network input is the same as in our previous studies: ${\tau }_{ext}-{\tau }_F$ estimated from robot dynamics using an MOB. The dynamics of an n-joint open-chain manipulator can be expressed as

$$M\left(q\right)\ddot{q}+C(q,\dot{q})\dot{q}+g\left(q\right)+{\tau }_F={\tau }_m+{\tau }_{ext},$$

(1)

where $q,\dot{q},\ddot{q}\in {\mathbb{R}}^n$ respectively denote joint position, velocity, and acceleration, $M\left(q\right)\in {\mathbb{R}}^{n\times n}$ is the symmetric positive-definite mass matrix, $C(q,\dot{q})\in {\mathbb{R}}^{n\times n}$ is the Coriolis matrix, $g\left(q\right)\in {\mathbb{R}}^n$ is the gravity vector, ${\tau }_F\in {\mathbb{R}}^n$ represents the joint frictional torque, ${\tau }_m\in {\mathbb{R}}^n$ is the motor torque calculated as ${\tau }_m=K_i{i}_m$ from the measured motor current $i_m\in {\mathbb{R}}^n$ and diagonal gain matrix $K_i\in {\mathbb{R}}^{n\times n}$, and ${\tau }_{ext}\in {\mathbb{R}}^n$ denotes the external joint torque caused by collisions.

The generalized momentum of the robot is defined as $p=M\left(q\right)\dot{q}\in {\mathbb{R}}^n$, and its time derivative can be written as

$$\dot{p}={\tau }_m+{\tau }_{ext}-{\tau }_F-g\left(q\right)+C^T(q,\dot{q})\dot{q},$$

(2)

where the passivity property of robot dynamics

$$\dot{M}\left(q\right)=C(q,\dot{q})+C^T(q,\dot{q})$$

(3)

and the robot dynamics (1) are used [27].

As shown in Figure 1, a simplified MOB that omits the joint friction term—to avoid explicit friction modeling, which is challenging due to its highly nonlinear characteristics—is employed to estimate the external torque. Using the notation $\beta (q,\dot{q}):=g\left(q\right)-C^T(q,\dot{q})\dot{q}$, the MOB dynamics is formulated as

$$\begin{array}{cc}\hfill \dot{\widehat{p}}& ={\tau }_m-\widehat{\beta }(q,\dot{q})+r,\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill \dot{r}& =K_O(\dot{p}-\dot{\widehat{p}}),\hfill \end{array}$$

(5)

where $K_O\in {\mathbb{R}}^{n\times n}$ is the positive-definite diagonal MOB gain matrix. All elements of $K_O$ were set to 150. The MOB output $r\in {\mathbb{R}}^n$ is then

$$r=K_O\left(p\left(t\right)-{\int }_0^t({\tau }_m-\widehat{\beta }+r)ds-p\left(0\right)\right)$$

(6)

with $p=\widehat{M}\left(q\right)\dot{q}$ and $\widehat{\beta }=\widehat{g}\left(q\right)-{\widehat{C}}^T(q,\dot{q})\dot{q}$. The terms $\widehat{M}$, $\widehat{C}$, and $\widehat{g}$ denote the nominal model parameters, and under ideal conditions in which these parameters exactly match their true values, the dynamic relation between r and ${\tau }_{ext}$ results in

$$\dot{r}=K_O({\tau }_{ext}-{\tau }_F-r).$$

(7)

This implies that the output r of the simplified MOB acts as a filtered estimate of ${\tau }_{ext}-{\tau }_F$. Although r contains both external and frictional components, we later experimentally show that our learning-based method effectively compensates for the unmodeled friction, allowing for accurate detection and classification of hard and soft collisions.

Figure 1. Simplified MOB that omits the joint friction term.

2.3. Collision Scenarios

The collision scenarios of the dataset were designed to encompass situations that the robot may encounter in various working environments. For robot motion, the robot followed random six-joint point-to-point trajectories. During operation, three payload conditions were considered by attaching different masses to the end-effector: 0 kg (no payload), 3.3 kg, and 5 kg. While the robot was moving or stationary, hard and soft collisions were applied randomly to links 2–6 using a handheld tool integrated with a force-sensitive resistor. In collision-free cases, the robot operated freely without any external interactions. The three scenarios are summarized as follows.

1.

Hard collisions: sharp impact collisions produced by quickly striking the robot; typical duration is 10–100 ms.

2.

Soft collisions: pushing-type collisions produced by slowly pressing the robot; typical duration is 100–700 ms.

3.

Collision-free: the robot executes motions with no contact.

Further details, including demonstrations of the data collection process for each scenario, are provided in [23,24].

2.4. Test Data for Performance Evaluation

The test data for evaluating the collision detection and classification performance are summarized in Table 1 (number of collisions and execution time), where the dataset comprises all three scenarios considered in our study: hard collisions, soft collisions, and collision-free operation. The hard and soft collision data contain 578 hard collision events and 209 soft collision events respectively (787 in total), while the collision-free data consist of 62.4 min of free motion with no collision events. Figure 2 shows the distributions of collision links, peak forces, and durations, which together demonstrate the diversity of the test collisions in terms of location, intensity, and duration. In addition, due to the repeated application of collisions under random motions and configurations, the collisions effectively cover a wide range of force directions.

Table 1. Test data for collision detection and classification performance evaluation.

Payload	0 kg	3.3 kg	5 kg	Total
Hard collisions	204	195	179	578
Soft collisions	94	66	49	209
Collision-free	20.6 min	21.1 min	20.7 min	62.4 min

Figure 2. Distributions of (a) collision links, (b) peak collision forces, and (c) collision durations of the test collisions. The vertical axis represents the number of collisions.

3. Learning-Based Models for Collision Detection and Classification

3.1. GRU and Stacked GRU

In this study, we use the GRU [28] illustrated in Figure 3a as the temporal modeling backbone. GRUs are a variant of recurrent neural networks (RNNs) designed to capture sequential dependencies in time-series data while alleviating the vanishing gradient problem of standard RNNs. A GRU cell consists of two gates: the update gate and the reset gate. The update gate determines how much of the previous hidden state should be retained (i.e., determines the mixing ratio of past and current information), while the reset gate controls how much past information should be discarded. LSTM networks were originally introduced to address the same vanishing gradient issue [29], using three separate gates (input, forget, output). By consolidating these three gates into two, the GRU achieves a simpler architecture that is more computationally efficient and provides better generalization capability while still maintaining the ability to learn long-term dependencies.

Figure 3. (a) A GRU cell consists of the reset gate (blue) and the update gate (yellow). The GRU output at time t is $h_t$. (b) A two-layer stacked GRU architecture. The result of the first GRU layer (lower layer) is the input to the second layer (upper layer).

To further enhance the representation capability, we adopt the stacked GRU architecture, in which multiple GRU layers are arranged sequentially—in our case, the two-layer architecture illustrated in Figure 3b. This hierarchical structure enables the lower layer to capture short-term fluctuations in the input sequence, while the higher layer integrates these features to model more complex, long-term dependencies. By leveraging this architecture, the model can effectively discriminate subtle temporal patterns associated with different collision events.

3.2. Network Input Construction

The monitoring signal $r\left(t\right)\in {\mathbb{R}}^6$ estimated by the MOB at each time step (1 ms) is captured over a sliding time window of size $t_W$, sampled at a sampling interval of $t_I$, and transformed to construct the network input. In the window-capturing step, as illustrated in Figure 4, the segment of $r\left(t\right)$ within the range $[t-t_W,t]$, i.e.,

$$X_W={[r(t-t_W),r\left(t\right)]}^T\in {\mathbb{R}}^{(t_W+1)\times 6},$$

(8)

is extracted at time t. The sliding window moves with a stride of $t_s$ during training data collection, whereas real-time collision detection performs window extraction at every time step to generate a continuous stream of input segments.

Figure 4. Extraction of monitoring signal $r\left(t\right)$ over a sliding time window of size $t_W$.

When extracting training data from the collision (hard and soft) datasets, only those $X_W$ whose true collision index at the window head indicates a collision event ($true=1$), i.e., the most recent sample $r\left(t\right)$ has entered the collision zone, are selected. For the collision-free dataset, on the other hand, all window segments are included since the true collision index is always $false=0$. After the extraction, $X_W$ is downsampled at the sampling interval $t_I$ to obtain $X_S\in {\mathbb{R}}^{(t_W/t_I+1)\times 6}$, as illustrated in Figure 5. This results in $t_W/t_I+1=N+1$ samples per window. $X_S$ can be written as

$$X_S=\left[\begin{array}{c}{r}^T\left(t-t_W\right)\\ ⋮\\ r^T(t-t_I)\\ r^T\left(t\right)\end{array}\right]=\left[\begin{array}{cccccc}|& |& |& |& |& |\\ r_1& r_2& r_3& r_4& r_5& r_6\\ |& |& |& |& |& |\end{array}\right]\in {\mathbb{R}}^{(N+1)\times 6},$$

(9)

where the jth column $r_j\in {\mathbb{R}}^{N+1}$ represents the sampled monitoring signal of joint j within the sliding window. In this study, we set $t_W=100$ ms for window extraction and $t_I=10$ ms for sampling, yielding $N=t_W/t_I=10$ and $X_S\in {\mathbb{R}}^{11\times 6}$. The extracted and sampled matrix $X_S$ is then used as input to each network (detection and classification) after applying the network-specific transformations described in the following sections.

Figure 5. Downsampling of the extracted $X_W$ at sampling interval $t_I$.

3.2.1. Training Data for Detection Learning

Since the magnitude of the estimated external joint torque is the primary indicator for detecting collisions, we take the absolute value of $X_S$:

$$|X_S|=\left[\begin{array}{cccccc}|& |& |& |& |& |\\ |r_1|& |r_2|& |r_3|& |r_4|& |r_5|& |r_6|\\ |& |& |& |& |& |\end{array}\right].$$

(10)

Each element of the non-negative matrix $|X_S|$ is then normalized using min-max normalization:

$$|r_{ij}|\leftarrow |r_{ij}|/|r_j{|}_{\max },$$

(11)

where $|r_{ij}|$ denotes the ${(i,j)}^{\mathrm{th}}$ element of $|X_S|$, and $|r_j{|}_{\max }$ is computed independently for each joint from the absolute monitoring signal $|r_j\left(t\right)|$ over the entire training dataset (hard, soft, collision-free). After these transformations, the network input for collision detection $X_D\in {\mathbb{R}}^{11\times 6}$ is constructed.

During training data collection, the sliding window moves with a stride of $t_s=5$ ms, generating $X_D$ samples by applying the sampling and transformation procedures to the extracted signal. This yields a total of 796,646 training samples: 7018 hard collision samples, 40,967 soft collision samples, and 748,661 collision-free samples. For collision detection, the labeling scheme merges hard and soft collisions into a single collision class. Each sample is assigned a binary true label $l_D$: collision samples (both hard and soft) are labeled $l_D=\mathit{true}$, while collision-free samples are labeled $l_D=false$. The collected pairs

$${\mathcal{D}}_{\mathrm{detection}}=\{{(X_D,l_D)}_{\mathrm{collision}},{(X_D,l_D)}_{\mathrm{free}}\}$$

(12)

are used for training the network, while during real-time collision detection, only $X_D$ is provided as input to predict the collision index (i.e., collision occurrence).

3.2.2. Training Data for Classification Learning

Input design for the collision classification model begins with the same matrix $X_S$ obtained by applying the sliding window extraction and sampling processes employed in the detection model. Since the classification model must distinguish the subtle temporal characteristics of the two collision types, $X_S$ undergoes an additional preprocessing step to amplify these distinctions.

The first row of $X_S$ corresponds to the earliest observation within the window, $r(t-10t_I)$, and the last row is the most recent (final) observation $r\left(t\right)$. The key distinction between hard and soft collisions lies in their temporal profiles: hard collisions exhibit a rapid increase in the monitoring signal, while soft collisions show a more gradual rise. To better capture these differences, we apply a deviation operation along the time axis. We compute the deviation relative to the final observation by subtracting each preceding sample from the last observation:

$$X_{SD}=\left[\begin{array}{c}{r}^T\left(t\right)-r^T\left(t-10t_I\right)\\ ⋮\\ r^T\left(t\right)-r^T(t-2t_I)\\ r^T\left(t\right)-r^T(t-t_I)\end{array}\right]\in {\mathbb{R}}^{10\times 6}.$$

(13)

Each row of $X_{SD}$ represents the difference between a past observation and the final observation, therefore capturing the temporal changes throughout the collision event.

To enhance the separability of collision types and suppress torque directional dependency, we square $X_{SD}$ elementwise: $X_{SD}\odot X_{SD}$. This (1) removes sign information, highlighting only the magnitude of change, and (2) amplifies the disparity between hard and soft collisions, as the sharper transitions in hard collisions become more pronounced after squaring. Subsequently, min-max normalization [Equation (11)] is applied to the squared $X_{SD}$ in the same manner, except that the maximum values for each joint are computed over the collision training dataset (hard, soft). This produces the network input for collision classification $X_C\in {\mathbb{R}}^{10\times 6}$, which effectively encodes the temporal profiles of the two collision types.

For training data collection, the sliding window moves with a stride of $t_s=1$ ms throughout the collision dataset, generating a total of 239,976 training $X_C$ samples: 35,100 hard collision samples and 204,876 soft collision samples. Each sample is assigned a true class label $l_C$ based on the collision type: $l_C=1$ for hard collisions and $l_C=2$ for soft collisions. The collected pairs

$${\mathcal{D}}_{\mathrm{classification}}=\{{(X_C,l_C)}_{\mathrm{hard}},{(X_C,l_C)}_{\mathrm{soft}}\}$$

(14)

are then used to train the collision classification network. For real-time collision classification, which is triggered only when a collision is detected by the collision detection network, only $X_C$ is provided as input to determine the type of the detected collision. The detailed operation flow of real-time detection and classification is described in Section 3.5.

3.3. Network Architecture and Training

3.3.1. Collision Detection Model

After the collision detection model is trained, it receives the preprocessed input matrix $X_D$—which is constructed through the sliding window extraction, downsampling, and transformation procedures described in Section 3.2.1—at every time step and outputs a binary label indicating whether the current robot state corresponds to a collision event ($true$) or a collision-free state ($false$).

The detection network employs the stacked GRU architecture, as detailed in Table 2. The network consists of two sequential unidirectional GRU layers with 128 and 64 hidden units, respectively. Both GRU layers return the full output sequence, therefore preserving temporal information across all time steps. A global mean pooling operation is then applied along the temporal dimension to aggregate the sequential features into a fixed-length representation. The classification head comprises three fully connected (FC) blocks, each consisting of an FC layer followed by Batch Normalization and Leaky ReLU activation ($\alpha =0.1$). Dropout regularization is applied after each layer to prevent overfitting.

Table 2. Architecture of the proposed collision detection network. The batch size b is 2048 during training and 1 during real-time inference.

Layer	Input Shape	Hidden Units	Return Full Sequence	Dropout	Output Shape
Uni-GRU 1	$(b,11,6)$	128	True	0.2	$(b,11,128)$
Uni-GRU 2	$(b,11,128)$	64	True	0.15	$(b,11,64)$
Mean pooling	$(b,11,64)$	-	-	-	$(b,64)$
FC block 1	$(b,64)$	128	-	0.25	$(b,128)$
FC block 2	$(b,128)$	64	-	0.2	$(b,64)$
FC block 3	$(b,64)$	32	-	0.15	$(b,32)$
Output	$(b,32)$	2	-	-	$(b,2)$

The model is trained using the Binary Cross-Entropy loss and the Adam optimizer for 200 epochs, with a batch size of 2048 and an initial learning rate of 0.001. The training dataset ${\mathcal{D}}_{\mathrm{detection}}$ consisting of 796,646 samples (47,985 collision and 748,661 collision-free) is split into training and validation sets with an 8:2 ratio. To suppress false positives caused by transient noise and enhance detection reliability, a continuous filter is applied to the model outputs, with details provided in Section 3.4.1.

3.3.2. Collision Classification Model

Once a collision is detected, the collision classification model subsequently determines whether it is a hard collision or a soft collision. The preprocessed matrix $X_C$ constructed by following the procedures described in Section 3.2.2 is provided as the network input, and the model outputs a binary classification result: hard collision (class 1) or soft collision (class 2).

The classification network adopts the same stacked GRU architecture as the detection network, as shown in Table 3. The only structural difference lies in the input dimension: the input layer receives an input of shape $(b,10,6)$ instead of $(b,11,6)$, reflecting the reduced temporal dimension resulting from the deviation operation. The subsequent layers—two GRU layers, global mean pooling, three FC blocks, and the output layer—remain identical to those of the detection model.

Table 3. Architecture of the proposed collision classification network. The batch size b is 2048 during training and 1 during real-time inference.

Layer	Input Shape	Hidden Units	Return Full Sequence	Dropout	Output Shape
Uni-GRU 1	$(b,10,6)$	128	True	0.2	$(b,10,128)$
Uni-GRU 2	$(b,10,128)$	64	True	0.15	$(b,10,64)$
Mean pooling	$(b,10,64)$	—	—	—	$(b,64)$
FC block 1	$(b,64)$	128	—	0.25	$(b,128)$
FC block 2	$(b,128)$	64	—	0.2	$(b,64)$
FC block 3	$(b,64)$	32	—	0.15	$(b,32)$
Output	$(b,32)$	2	—	—	$(b,2)$

The model is trained using the Binary Cross-Entropy loss and the Adam optimizer for 200 epochs, with a batch size of 2048 and an initial learning rate of 0.001. The training dataset ${\mathcal{D}}_{\mathrm{classification}}$ comprising 239,976 collision samples (35,100 hard and 204,876 soft) is split into training and validation sets with an 8:2 ratio. To reduce momentary prediction errors and improve classification stability, a temporal majority filter is applied before classification confirmation; its design and operation are described in Section 3.4.2.

3.4. Output Filtering Methods

3.4.1. Continuous Filter for Collision Detection

The output of the collision detection network may become temporarily unstable due to transient disturbances such as measurement noise or tremors, potentially leading to false positives (false alarms) during collision-free motion. To suppress such false positives and therefore maintain productivity, we apply a simple output filtering technique. Specifically, we employ a continuous filter [23] that requires the collision detection model to predict collision ($true$) continuously for a minimum duration of $t_c$ ms before confirming an actual collision event. This temporal consistency requirement effectively eliminates false positives caused by instantaneous spike-like noise or brief sensor anomalies, enhancing the robustness of the detection model. The filter parameter $t_c$ represents the minimum continuous duration required for collision confirmation, introducing a minimum detection delay of $t_c$ ms. The parameter can be adjusted according to application requirements (e.g., safety versus productivity) and the acceptable trade-off between detection delay and false-positive reduction.

3.4.2. Temporal Majority Filter for Collision Classification

To improve the accuracy of the collision classification model, we apply a temporal majority filter [30] before classification confirmation. Once a collision has been detected by the detection model, the classification model continuously outputs type predictions for the detected collision over a specified window of duration $t_v$ ms. The predictions are collected throughout the window, after which a majority voting mechanism is applied; the class (hard or soft) that appears most frequently is selected as the final collision type. This temporal aggregation approach mitigates the impact of momentary misclassifications (especially those occurring at collision onset) and yields a more reliable classification result. The filter parameter $t_v$ controls the length of the voting window, which in turn imposes a fixed decision latency of $t_v$ ms, and can be tuned to balance the classification accuracy between hard and soft collisions.

3.5. Operation Flow of Collision Handling

Figure 6 illustrates the overall operation flow of the proposed collision handling pipeline, which consists of sequential detection and classification stages executed in real time during robot operation.

Figure 6. Schematic diagram of the real-time collision detection and classification pipeline. The system estimates the monitoring signal $r\left(t\right)$ from joint measurements and the robot dynamic model, detects collisions using $X_D$ constructed from $r\left(t\right)$, and upon collision detection, performs collision classification with $X_C$, also constructed from $r\left(t\right)$.

1.

The system continuously estimates the monitoring signal $r\left(t\right)\in {\mathbb{R}}^6$ at every time step. The signal is the output of the simplified MOB that omits the joint friction term, providing a filtered estimate of ${\tau }_{ext}-{\tau }_F$.

2.

The acquired $r\left(t\right)$ is pushed into the sliding time window of size $t_W=100$ ms, which is implemented as a buffer storing the recent history of the monitoring signal (i.e., $X_W\in {\mathbb{R}}^{101\times 6}$). After downsampling at sampling interval $t_I=10$ ms, producing $X_S\in {\mathbb{R}}^{11\times 6}$, the collision detection network input $X_D\in {\mathbb{R}}^{11\times 6}$ is constructed.

3.

With the input matrix $X_D$, the detection network outputs a binary prediction: true or false. To eliminate transient false positives, a continuous filter of duration $t_c$ ms is applied, confirming a collision only when the prediction remains true throughout the entire $t_c$ ms period.

4.

If the filtered detection result indicates no collision, the robot continues its normal operation while monitoring collisions. If a collision is confirmed, the collision type classification stage is initiated and the detection stage is temporarily disabled.

5.

Following collision detection, the system continues to estimate $r\left(t\right)$ and updates the sliding window $X_W$ and the downsampled matrix $X_S$. For classification, $X_C\in {\mathbb{R}}^{10\times 6}$ is obtained based on the temporal deviation operation and the subsequent preprocessing steps.

6.

The collision classification network takes $X_C$ as input and outputs a collision type prediction: hard or soft. These predictions are collected over the $t_v$ ms voting window, and the majority class is selected as the final classification result.

Depending on the operational context and the level of responsiveness required, the proposed collision handling pipeline can be used in two ways. If only collision detection is required, the detection stage alone is sufficient. In this mode, the robot would perform a single predefined safety action (e.g., an emergency stop) whenever a collision is detected. If collision type information is needed to enable more diverse reaction strategies, the full pipeline can be employed. This modular separation of detection and classification (1) provides users with the flexibility to choose the functionality appropriate for their application and (2) contributes to real-time performance by avoiding simultaneous execution of the two networks. Furthermore, additional collision handling modules (e.g., localization) can be added to the pipeline if required by the application. Despite these advantages, the current sequential design may fail to detect collisions that occur during the classification stage (as collision detection is temporarily disabled), particularly in scenarios involving repeated collisions within short time intervals (i.e., overlapping collisions). This operational constraint suggests the need for an integrated design that enables simultaneous detection and classification.

4. Performance Evaluation and Discussion

We verify the performance of the proposed collision detection and classification methods using the test data summarized in Table 1, which consist of 578 hard collisions, 209 soft collisions, and 62.4 minutes of collision-free motion. An event-based evaluation framework is adopted, where the priority is to identify collision events rather than focusing on sample-level classification results (i.e., model outputs at each time step).

For detection performance evaluation, we measure the average detection delay (aDD) and the number of detection failures (DFs) over the 787 test collisions, and count the number of false positives (FPs) during the 62.4-minute collision-free test motion. As discussed in Section 3.4.1, detection performance varies with the length $t_c$ of the continuous filter: increasing $t_c$ reduces FPs while increasing aDD, whereas smaller values of $t_c$ lead to faster detection at the cost of increased false alarms. Since aDD/DFs and FPs exhibit a trade-off relationship, we follow the same evaluation procedure as in our previous works by setting $t_c$ to the minimum value that results in zero FPs (i.e., the most sensitive setting without false alarms), after which aDD and DFs are measured. The minimum value of $t_c$ can be automatically determined from a sufficiently representative period of collision-free motion, without requiring manual tuning. While the detection performance evaluation validates compensation for unmodeled friction, we further analyze the robustness of the proposed detection model to dynamic model uncertainty, i.e., its generalization capability under simulated dynamic model errors.

For classification performance evaluation, we assess the classification accuracy of each collision type (i.e., count the number of misclassifications). We analyze the effect of the filter parameter $t_v$ (see Section 3.4.2) on the classification accuracy of each collision type and discuss the corresponding tuning strategy for $t_v$.

4.1. Detection Performance Evaluation

4.1.1. Performance Comparison with Baseline

The objective of this section is to evaluate the fundamental performance of the proposed detection method and to verify its capability to detect collisions while effectively compensating for unmodeled friction and dynamic model uncertainties through collision data learning. As shown in Table 4, the proposed stacked GRU-based detection model is benchmarked against the 1-D CNN-based baseline developed in our previous work [23] to demonstrate the improved detection performance and the effectiveness of the proposed GRU-based architecture. To eliminate all FPs, continuous filters with $t_c=5$ ms and $t_c=4$ ms are applied to the proposed method and the baseline respectively.

Table 4. Collision detection performance of the proposed method and the baseline.

Network Architecture	GRU (Proposed)		1-D CNN [23]
Collision type	Hard	Soft	Hard	Soft
DFs	0/578	0/209	0/578	2/209
aDD	11.3 ms	13.5 ms	13.1 ms	26.9 ms
FPs	0/62.4 min		0/62.4 min

The proposed method outperforms the baseline in both detection speed (aDD) and reliability (DFs). Despite utilizing heavier output filtering than the baseline, the stacked GRU model achieves zero DFs across all test collisions and attains a lower aDD of 11.3 ms for hard collisions and 13.5 ms for soft collisions. Figure 7 shows two example detection results, one hard collision and one soft collision, under no-payload condition. The detection delays are 8 ms and 6 ms respectively, where this latency arises from the propagation delay of the collision impact through the robot links, the inference delay caused by model prediction errors (not the network computation time), and the fixed delay of $t_c$ imposed by the continuous filter.

Figure 7. Detection results for (a) a hard collision and (b) a soft collision, both with no payload attached. Red stars denote the model predictions at each time step and the blue dashed line indicates the time at which the collision is detected after continuous filtering ($t_c=5$ ms). The detection delays from collision onset to detection are 8 ms and 6 ms respectively.

The superior performance of the stacked GRU, particularly for soft collisions, can be explained by its enhanced ability to model long-term temporal dependencies compared to the 1-D CNN. While the 1-D CNN extracts features based on local temporal patterns within a fixed-size receptive field, the recurrent architecture of the GRU enables more effective modeling of the temporal evolution of the monitoring signal. This distinction is especially important for soft collisions, which are characterized by a gradual increase in the external torque. The gating mechanism and internal hidden state of the GRU allow for robust tracking of these gradually increasing temporal patterns in the presence of unmodeled friction. As a result, the proposed model captures the transition from free motion to soft collision more rapidly and accurately than the CNN-based approach, which lacks explicit recurrent memory for modeling long-term temporal dependencies.

4.1.2. Generalization to Dynamic Model Uncertainties

While the robot dynamic model provides the basis for estimating the external joint torque, its practical application often involves discrepancies between the model parameters and the actual physical system. Such parametric uncertainty can arise from multiple factors, including (1) discrepancies between the CAD model and the actual robot, such as variations in mass, center of mass, and inertia matrices, (2) unmodeled dynamic elements, such as internal cables and motor rotor inertia, and (3) gradual changes due to wear and tear of robot components over time.

Although the detection performance presented in the previous section already indicates the robustness of the proposed detection model to unmodeled friction, we further validate its generalization capability to dynamic model uncertainties by explicitly evaluating detection performance under simulated parameter errors introduced by perturbations to M, C, and g. The effects of changes in C and g are jointly considered through the combined term $\beta =g-C^T\dot{q}$. The mass matrix M is varied within $\pm 10$% to reflect typical inertial parameter and payload uncertainties, while larger perturbations of $\pm 20$% are applied to $\beta$ to account for the higher sensitivity of C and g to velocity-dependent effects and center of mass uncertainties. The monitoring signal $r\left(t\right)$ is recomputed using the perturbed parameters to reflect the model uncertainties, resulting in less accurate estimates of ${\tau }_{ext}-{\tau }_F$. Without retraining or fine-tuning (i.e., additional adaptation), the previously trained detection network outputs collision index predictions using the recomputed monitoring signal as input. For each case, the continuous filter size $t_c$ is adjusted to suppress all FPs before measuring aDD and DFs. Perturbation conditions under which zero FPs cannot be achieved or multiple DFs occur are regarded as generalization failures.

Table 5 summarizes the detection performance at the boundary cases of the perturbation ranges where generalization is maintained. While achieving zero FPs with adjusted (increased) continuous filter duration $t_c$ ranging from 6 ms to 8 ms, the detection model maintains zero DFs within these ranges. Although a slight increase in aDD is observed after model perturbation, the proposed method still exhibits a detection delay comparable to the 1-D CNN-based baseline for hard collisions and achieves an approximately 10 ms smaller delay for soft collisions. The detection model fails to generalize in some perturbation ranges, where zero FPs cannot be achieved with adjusted continuous filter duration (DFs remain zero). The method fails to generalize when C and g are decreased by more than 10% under a 10% increase in M, and by more than 5% under a 10% decrease in M. In contrast, when C and g are increased, generalization is maintained across all tested perturbation ranges.

Table 5. Detection results under dynamic parameter errors introduced by perturbations to M, C, and g. All FPs are suppressed (i.e., zero FPs) prior to measuring aDD and DFs.

Model Error	($-10$%/$-5$%) ← C & g → ($+20$%)
($+10$%) ↑ M ↓ ($-10$%)	M +10%, C & g $-10\%$	M$+10\%$, C & g $+20\%$
	$t_c=8$ ms	$t_c=7$ ms
	Hard 13.6 ms (0 DFs)	Hard 12.5 ms (0 DFs)
	Soft 17.1 ms (0 DFs)	Soft 14.9 ms (0 DFs)
	M$-10\%$, C & g $-5\%$	M$-10\%$, C & g $+20\%$
	$t_c=7$ ms	$t_c=6$ ms
	Hard 12.6 ms (0 DFs)	Hard 11.5 ms (0 DFs)
	Soft 15.7 ms (0 DFs)	Soft 14.1 ms (0 DFs)
No model error	$t_c=5$ ms   Hard 11.3 ms (0 DFs)   Soft 13.5 ms (0 DFs)

The observed asymmetric generalization behavior can be attributed to the differing effects of modeling errors on the monitoring signal $r\left(t\right)$. Errors in the mass matrix primarily produce small transient deviations in $r\left(t\right)$ during joint acceleration and deceleration, whereas errors in the Coriolis and gravity terms typically generate larger sustained offsets throughout the motion, resulting in persistent disturbances in the network input. As a result, the detection model is more sensitive to perturbations in C and g than to errors in M (i.e., errors in C and g dominate the generalization performance). Negative perturbations of C and g tend to induce deviations in $r\left(t\right)$ that amplify its magnitude (i.e., overestimation of ${\tau }_F$), while positive perturbations exhibit the opposite tendency. Consequently, the detection model demonstrates stronger generalization robustness under positive perturbations.

Nevertheless, the proposed detection model maintains reliable performance over a fairly wide range of model perturbations with minimal parameter tuning. In particular, only the continuous filter duration $t_c$ requires adjustment, which can be automatically determined from a sufficiently long period of collision-free motion. These results indicate that the model has successfully learned generalizable physical features of collision events, demonstrating the practical significance of the proposed detection method for industrial collaborative robots that may be subject to dynamic uncertainties.

4.2. Classification Performance Evaluation

We now evaluate the performance of the collision classification model, which determines the type (hard or soft) of collisions that have been detected by the preceding detection model, under conditions with unmodeled friction. Since the detection model produces no FPs, all events identified as collisions correspond to true collisions; therefore, a two-class classification setting is sufficient, excluding collision-free cases. Classification performance is assessed in terms of class-wise accuracy for hard and soft collisions across different majority filter sizes $t_v$.

Figure 8 shows two example classification results, one hard collision and one soft collision. Once a collision is detected by the detection model (blue dashed line), the classification model outputs collision type predictions (red stars) over $t_v$ time steps (green line), after which majority filtering is applied to determine the type of the detected collision event. In the above case, with $t_v$ set to 55 ms, 43 hard-type and 12 soft-type predictions are collected within the majority filter window, resulting in a hard-type classification. The bottom case is classified as a soft collision following the same procedure with $t_v=65$ ms. In both cases, misclassifications are observed in the early stage since $\left|r\right(t\left)\right|$ increases upon collision and may exhibit similar initial rising patterns for different collision types in some cases. Due to these early misclassifications, as $t_v$ is increased from 1 (i.e., no filtering), the hard, soft, and overall classification accuracies initially improve, and a stable classification accuracy is obtained for $t_v\ge 55$ ms. Table 6 shows the classification accuracies as $t_v$ is further increased from 55 ms. The classification accuracy for hard collisions, which reaches its highest value of 98.4% at $t_v=55$ ms, begins to degrade as $t_v$ increases. In contrast, soft collisions are better classified with larger values of $t_v$, achieving 100% accuracy at $t_v=79$ ms. An overall accuracy of 98.2% is observed at $t_v=65$ ms, representing a balanced classification performance.

Figure 8. Classification results for (a) a hard collision and (b) a soft collision, both with no payload attached. Blue dashed line indicates the time at which the collision is detected by the detection model, red stars denote the classification model predictions at each time step (1: hard, 2: soft), and green line indicates the time at which the collision is classified after majority filtering ($t_v=55$ ms and $t_v=65$ ms respectively).

Table 6. Collision classification results for different majority filter sizes ($t_v$).

Filter Size $\left({\mathit{t}}_{\mathit{v}}\right)$	Hard Collisions				Soft Collisions				Total
	Misclassifications			Accuracy (%)	Misclassifications			Accuracy (%)	Accuracy (%)
	0 kg	3.3 kg	5 kg		0 kg	3.3 kg	5 kg
55 ms	3/204	4/195	2/179	98.4	3/94	0/66	3/49	97.1	98.1
59 ms	6/204	4/195	2/179	97.9	2/94	0/66	2/49	98.1	98.0
65 ms	7/204	4/195	1/179	97.9	0/94	0/66	2/49	99.0	98.2
69 ms	7/204	4/195	2/179	97.8	0/94	0/66	2/49	99.0	98.1
75 ms	10/204	5/195	2/179	97.1	0/94	0/66	1/49	99.5	97.7
79 ms	10/204	6/195	3/179	96.7	0/94	0/66	0/49	100.0	97.6

The degradation of hard collision classification performance is attributed to the transient nature of hard impacts (i.e., their shorter duration). The classification model may continue producing collision type predictions even after the brief impact has ended and the subsequent propagated joint signals have subsided (i.e., during a collision-free state), leading to unreliable predictions at later stages [see Figure 8a]. These late misclassifications undermine the majority voting process and reduce the classification accuracy for hard collisions as $t_v$ increases. From an operational perspective, $t_v$ can be strategically tuned based on task-specific priorities: a shorter $t_v$ (e.g., 55 ms) is recommended for environments where transient impacts must be prioritized, while a longer $t_v$ (e.g., 79 ms) is preferable for applications requiring accurate identification of static contact scenarios. Throughout this range, the classification model consistently achieves high overall accuracy exceeding 97.5%. To further enhance usability by eliminating manual tuning, future work could explore an adaptive tuning method that automatically adjusts $t_v$ based on the context of the task or the operating environment.

4.3. Real-Time Inference

The proposed collision detection and classification models are optimized for real-time inference (i.e., computation time below 1 ms) on an RTX 3060 GPU. The key optimization techniques employed include: (1) FP16 mixed-precision inference to leverage Tensor Cores and reduce memory footprint; (2) JIT compilation to fuse operators and minimize kernel launch overhead; (3) CUDA streams with non-blocking data transfers to overlap kernel execution; and (4) an optimized inference engine that reuses input buffers to minimize memory allocation overhead. An average inference time of 0.461 ms is measured for the detection model and 0.448 ms for the classification model. Both models sustain a throughput of approximately 2.2 kHz, ensuring real-time performance for continuous inference applications.

5. Conclusions

In this paper, we presented a learning-based framework for real-time detection and classification of hard and soft collisions in collaborative robots without joint torque sensors. By leveraging a simplified MOB that omits the joint friction term and directly learning from the estimated monitoring signal $r\left(t\right)\approx {\tau }_{ext}-{\tau }_F$, the proposed method eliminates the need for additional sensors (e.g., joint torque sensors or external sensors) and explicit joint friction modeling while remaining suitable for practical industrial deployment in human–robot collaboration. A two-stage pipeline based on stacked GRU networks was introduced, in which collision detection and collision type classification are executed sequentially. The detection and classification performance was experimentally validated on a six-joint collaborative robot executing random point-to-point motions under three different payload conditions.

The detection model demonstrated robust and reliable real-time performance across diverse operating conditions, achieving zero FPs during 62.4 minutes of collision-free operation and zero DFs over 787 collision events. Compared to the 1-D CNN-based baseline [23], the proposed method achieved lower aDD—11.3 ms for hard collisions and 13.5 ms for soft collisions—with particularly notable improvements for soft collisions, highlighting the effectiveness of the GRU architecture in capturing gradually evolving collision dynamics under unmodeled friction. The robustness of the proposed detection model was further validated through systematic generalization experiments under simulated dynamic model uncertainties. Without retraining, reliable detection performance was maintained (i.e., the detection model successfully generalized) under perturbations in the mass matrix and Coriolis-gravity terms, requiring only minor adjustment of the continuous filter size $t_c$ to suppress FPs. This generalization capability is particularly significant for practical deployment, where industrial collaborative robots may be subject to uncertain or unmodeled dynamic effects. In such environments, avoiding repeated model identification or retraining is critical for maintaining safety and productivity during long-term operation.

Upon collision detection, the proposed classification model accurately distinguished between hard and soft collisions in real time, with overall accuracy consistently exceeding 97.5% across a range of output filter sizes $t_v$. The effect of the filter size was analyzed, and a corresponding tuning strategy was discussed—shorter $t_v$ for prioritizing hard collisions and longer $t_v$ when accurate identification of soft collisions is required. This classification capability has the potential to support differentiated post-collision reaction strategies, which are important for safe and flexible human–robot collaboration.

Overall, the proposed sensorless collision detection and classification framework provides a practical and cost-effective solution for real-world industrial environments through careful design of network inputs, temporal filtering strategies, and optimized network architectures. While the current binary classification (hard and soft) is effective for safety response selection, further study is needed to determine whether specific subtypes of soft collisions can be distinguished based on the temporal features of the monitoring signal and how such distinctions can improve post-collision reaction strategies. Moreover, we plan to investigate how to distinguish accidental collisions from intentional contacts (e.g., hand-guiding or cooperative manipulation), which may exhibit signal patterns similar to collisions. Finally, to ensure practical deployment, we aim to develop domain adaptation and transfer learning methods that enable the framework to generalize across different robot platforms, unseen payloads, and diverse human–robot collaborative tasks.