A collaborative robot on a production line streams joint currents, temperatures, and speeds every cycle. That telemetry contains everything you need to catch a protective stop or a gripping failure before it halts the line. The problem is where the model runs. Send the data to the cloud and you're adding latency and network dependency to a system that needs to respond within a cycle time. Run the model on the controller and you're fighting for memory and compute against the real-time control loop.
This paper asks a narrow question: how small can you make a time-series fault predictor for a cobot while keeping it accurate enough to trust?
Understanding robotic arm data
We used the public UR3 CobotOps dataset, which logs 19 sensor channels across 240 operation cycles of a Universal Robots UR3 cobot. Each cycle gets two binary labels: did a protective stop happen, and did a grip loss happen. We resampled every cycle to a fixed length of 25 time steps, standardized the features, and framed it as a multi-label sequence classification task. Simple enough to implement on or near the controller.
We compared three architectures: a two-layer LSTM, a dilated Temporal Convolutional Network, and a CNN-LSTM hybrid. Same training protocol, same metrics, same test split.
Prescriptive maintenance to avoid production downtime
The TCN and CNN-LSTM clearly outperformed the vanilla LSTM. The TCN hit 0.83 F1-macro with 0.957 ROC-AUC. The CNN-LSTM hit 0.81 F1-macro with 0.982 ROC-AUC. The LSTM trailed at 0.68. Convolutional front-ends are better matched to these short, structured sequences than pure recurrence.
The CNN-LSTM is the interesting one for edge deployment. It uses only 15% of the TCN's parameters but matches or beats it on most metrics. That ratio matters when you're fitting models onto industrial PCs.
Figure 1. Validation loss, F1-macro, F1-micro, and Hamming loss over training epochs for LSTM, TCN, and CNN–LSTM on the UR3 CobotOps cycle-level fault task. TCN and CNN–LSTM converge faster and reach higher F1 and lower Hamming loss than the LSTM, indicating that convolutional front-ends better exploit the short multivariate sequences.
Compression without casualties
We designed a mixed quantization flow that respects the numerical properties of different operators. Convolutional and linear layers get static INT8 post-training quantization. LSTM layers get dynamic quantization, which stores weights in INT8 but keeps activations in floating point. For the CNN-LSTM we combine both: the convolutional frontend is statically quantized, the recurrent backend is dynamically quantized, with explicit bridge nodes between them.
The results surprised us. Quantization didn't just preserve accuracy, it slightly improved it for the convolutional models. The INT8 TCN gained 3 points in F1-macro over its FP32 baseline. The INT8 CNN-LSTM gained 2.3 points. Both held their ROC-AUC within 0.001.
On the efficiency side, the CNN-LSTM compressed from 1.23 MB to 0.47 MB and went from 19.4 ms per cycle to 5.8 ms, a 3.35x speedup. All three models fit under 2 MB after quantization. That means a single controller could host multiple compressed models, one per cobot or one per failure mode, without saturating compute or storage.
Why this matters for the factory floor
Per-label confusion matrices and ROC curves confirmed that compression doesn't hide systematic blind spots. For protective stops, the INT8 models maintain near-perfect detection. For grip loss, quantization slightly shifts the false-positive and false-negative balance but preserves high recall, which is the right trade in safety-critical operations. You'd rather flag a cycle that turns out fine than miss one that doesn't.
The broader point is practical. A quantized CNN-LSTM at half a megabyte and 6 ms per cycle is small enough and fast enough to run on the hardware that already exists in most production lines. No new infrastructure. No cloud dependency. Each cobot generates a compact health score every cycle, and only those summaries need to leave the node.
S.