Explainable and Hardware-Efficient Jamming Detection for 5G Networks Using the Convolutional Tsetlin Machine

This paper proposes and validates a hardware-efficient, explainable Convolutional Tsetlin Machine (CTM) for real-time 5G jamming detection that achieves comparable accuracy to convolutional neural networks while significantly reducing training time, memory usage, and enabling deterministic FPGA deployment.

The Gist

Imagine you are living in a bustling city where everyone communicates by shouting messages across a giant, invisible radio wave. This is 5G, the super-fast network that powers our phones, self-driving cars, and smart factories.

But there's a problem: Jammers.

Think of a jammer as a mischievous person standing in the middle of the square with a megaphone, shouting nonsense just loud enough to drown out the important messages, but quiet enough that the police (the network's standard monitoring tools) don't notice them. If this happens, your self-driving car might not see a stop sign, or your factory robot might stop working.

This paper introduces a new, clever way to catch these jammers. It compares two "detectives" trying to solve the mystery: a Super-Intelligent Giant (a standard AI called a CNN) and a Smart, Tiny Detective (a new type of AI called the Convolutional Tsetlin Machine, or CTM).

Here is the breakdown of their battle:

1. The Crime Scene: The "Synchronization Signal"

In 5G, the network sends out a very specific, rhythmic "heartbeat" signal called the SSB (Synchronization Signal Block). It's like a lighthouse beam that ships (your phone) use to find their way.

• Normal day: The lighthouse beam is steady and clear.
• Jamming day: A jammer tries to flicker or distort that beam.

The paper's detectives look only at this lighthouse beam to figure out if someone is messing with it. They don't need to check the whole city; just the beam is enough.

2. The Two Detectives

The Giant: The Convolutional Neural Network (CNN)

• Who it is: A massive, highly trained brain. It's like a PhD student who has read every book in the library.
• How it works: It looks at the signal and uses complex math (floating-point numbers) to guess if it's a jammer. It's incredibly good at spotting patterns.
• The Catch: It's heavy. It needs a huge backpack (lots of memory) to carry all its knowledge. It takes a long time to study (train) and needs a powerful computer (like a supercomputer) to run. It's like trying to carry a PhD student in a backpack onto a bicycle; it's possible, but it's slow and clunky.

The Tiny Detective: The Convolutional Tsetlin Machine (CTM)

• Who it is: A clever, logic-based detective. It's like a Sherlock Holmes who solves crimes using simple "If/Then" rules (Boolean logic).
• How it works: Instead of complex math, it turns the signal into simple On/Off switches (like a light switch). It asks questions like: "If the signal is ON at this spot AND OFF at that spot, then it's a jammer!"
• The Superpower: Because it only uses simple switches, it is tiny, fast to learn, and easy to explain. You can literally look at its rules and say, "Ah, I see why it caught that jammer."

3. The Showdown: Who Wins?

The researchers tested both detectives on real 5G data. Here is how they compared:

| Feature | The Giant (CNN) | The Tiny Detective (CTM) | The Analogy |
| :--- | :--- | :--- | : |
| Accuracy | 96.8% (Very High) | 91.5% (Very Good) | The Giant is slightly better at spotting the bad guy, but the Tiny Detective is still very reliable. |
| Training Time | 3,200 seconds (Slow) | 320 seconds (Fast!) | The Giant took a whole day to study; the Tiny Detective learned in an hour. |
| Memory Size | 624 MB (Huge) | 45 MB (Tiny) | The Giant needs a warehouse to store its notes; the Tiny Detective fits in a pocket notebook. |
| Hardware | Needs a big server. | Can run on a tiny chip (FPGA). | The Giant needs a Ferrari engine; the Tiny Detective runs on a bicycle gear. |
| Explainability | "Black Box." We don't know why it decided. | "Glass Box." We can see the exact rules it used. | The Giant gives you a verdict; the Tiny Detective gives you the verdict and the evidence. |

4. Why Does This Matter? (The "Edge" Concept)

The paper argues that for 5G networks, especially in places like cars, drones, or remote sensors (called "Edge AI"), we don't always need the biggest, smartest brain. We need something that:

1. Fits in a small box (Low memory).
2. Runs on a small battery (Low power).
3. Makes decisions instantly (Low latency).
4. Can be trusted (Explainable).

The CTM is the perfect candidate for this. It's like putting a super-efficient, solar-powered security camera on a remote fence post. It doesn't need to be connected to a massive server farm; it can think for itself right there on the fence.

The Verdict

• If you have a supercomputer and need the absolute highest accuracy possible, use the Giant (CNN).
• If you are building a smart device for a car, a drone, or a factory where space, battery, and speed are critical, use the Tiny Detective (CTM).

The Bottom Line: This paper proves that you don't need a "super-brain" to catch radio jammers. A smart, simple, logic-based detective can do the job almost as well, but it's faster, cheaper, and fits in your pocket. This is a huge step toward making our future 5G and 6G networks safer and more secure for everyone.

Technical Summary

Here is a detailed technical summary of the paper "Explainable and Hardware-Efficient Jamming Detection for 5G Networks Using the Convolutional Tsetlin Machine."

1. Problem Statement

Fifth-generation (5G) networks rely on stable radio-frequency (RF) environments to support mission-critical services. However, these networks are vulnerable to intentional interference (jamming), particularly low-power attacks that remain undetected by traditional link-layer monitoring and performance counters.

• The Challenge: Existing Deep Learning (DL) solutions (e.g., CNNs) often achieve high accuracy but suffer from high memory footprints, expensive training costs, and a lack of interpretability, making them unsuitable for resource-constrained edge devices (IoT, vehicular platforms).
• The Target: The authors focus on the Synchronization Signal Block (SSB), specifically the Primary Synchronization Signal (PSS). Because the PSS has a deterministic structure and fixed periodicity, distortions in its signal can reveal jamming even when link-layer metrics are inconclusive.

2. Methodology

The paper proposes a lightweight, explainable detection framework using the Convolutional Tsetlin Machine (CTM) operating directly on over-the-air 5G SSB features.

A. System Model & Data Acquisition

• Signal Source: Over-the-air 5G FR1 (n71 band) signals captured using a ThinkRF RTSA R5500 spectrum analyzer.
• Jamming Simulation: Controlled jamming is simulated by injecting synthesized interference waveforms via an RF combiner at the receiver front-end.
• Preprocessing:
  1. Synchronization: Blind search for Carrier Frequency Offset (CFO) and Schmidl-Cox method for Time Offset (TO) estimation.
  2. Extraction: Isolation of the first OFDM symbol ($l=0$) containing the PSS.
  3. Feature Generation: Short-time FFT applied to generate time-frequency spectrograms.
  4. Booleanization: Crucial for CTM, the continuous spectrogram data is converted into binary features. The paper compares four methods, with Enhanced Otsu (applying Otsu thresholding to the original and 90°-rotated image, combined via logical OR) yielding the best results.

B. The Convolutional Tsetlin Machine (CTM)

• Core Mechanism: Unlike Deep Neural Networks (DNNs) that use floating-point weights, the CTM uses Tsetlin Automata (TAs) to learn propositional logic clauses over Boolean inputs.
• Architecture: The CTM processes input in patches (convolutional view), attaching coordinates to patches to learn spatial patterns.
• Inference: Operates via deterministic bit-wise logic, making it highly suitable for FPGA implementation (Look-Up Tables and Block RAM).
• Configuration: The model uses 200 clauses, a threshold ($T$) of 477, and a patch dimension of $10 \times 10$.

C. Baseline Comparison

A standard Convolutional Neural Network (CNN) was trained on the exact same dataset and preprocessing pipeline to serve as a benchmark.

• CNN Architecture: Four convolutional blocks (256 $\to$ 64 filters), followed by dense layers and a softmax head.
• Input: Normalized floating-point spectrograms (reshaped to $100 \times 100 \times 1$).

3. Key Contributions

1. Robust CTM Framework: Developed a jamming detection system operating directly on 5G SSB features without reliance on higher-layer Key Performance Indicators (KPIs). The model is fully explainable and hardware-efficient.
2. Comprehensive Benchmarking: Provided a direct comparison between CTM and CNN on real-world over-the-air data, highlighting the trade-offs between accuracy and resource efficiency.
3. FPGA Deployment Projections: Outlined three deployment profiles (Power, Latency, Accuracy) for the Zybo Z7 (Zynq-7000) FPGA board, projecting resource usage (LUTs) and throughput without requiring new physical measurements, based on prior CTM-FPGA literature.

4. Experimental Results

The models were evaluated on a real 5G testbed using 5-fold cross-validation on a Mac M1 Pro.

Metric	CTM (Proposed)	CNN (Baseline)	Advantage
Accuracy	$91.53 \pm 1.01%$|$96.83 \pm 1.19%$	CNN (Higher)
Training Time	~44 seconds	~3,205 seconds	CTM (9.5$\times$ Faster)
Model Memory	~45 MB	~624 MB	CTM (14$\times$ Smaller)
Inference Time	Slower (on CPU)	Faster (on CPU)	CNN (on general hardware)
Interpretability	High (Logic Clauses)	Low (Black Box)	CTM

• Training Efficiency: The CTM trains approximately 9.5 times faster than the CNN, making it ideal for scenarios requiring frequent model updates or retraining on edge devices.
• Memory Footprint: The CTM requires 14 times less memory, a critical factor for embedded systems.
• Explainability Analysis:
  • CNN: Focuses on specific high-frequency regions of the spectrogram but ignores lower bands.
  • CTM: Utilizes lower frequency bands across the full time slot, providing a more holistic view of the signal purity. The logic clauses explicitly show which features contribute to "Jamming" vs. "Pure" classifications.
• FPGA Projections: On a Zybo Z7 board, the CTM is projected to fit within modest LUT envelopes (7.7k–48k LUTs depending on the profile) and deliver throughput in the range of 1.0k–4.6k samples/second at 100 MHz.

5. Significance and Conclusion

This paper establishes the Convolutional Tsetlin Machine as a viable, practical alternative to Deep Learning for security-critical 5G applications.

• Trade-off Management: While the CNN offers slightly higher accuracy ($\sim$5% gain), the CTM offers a superior accuracy-efficiency trade-off for edge deployment. The marginal loss in accuracy is outweighed by massive gains in training speed, memory reduction, and interpretability.
• Edge AI Viability: The deterministic, bit-level nature of the CTM aligns perfectly with FPGA architectures, enabling fully on-chip, low-power, and low-latency jamming detection.
• Future Impact: The work lays the groundwork for Beyond 5G (B5G) systems where security must be integrated directly into the physical layer with minimal resource overhead. The authors suggest future work will explore hybrid CTM/CNN models and hardware-in-the-loop evaluations to further optimize resilience in dynamic RF environments.

Summary Verdict: For general-purpose computing where peak accuracy is paramount, CNNs are preferred. However, for resource-constrained, security-critical edge environments requiring explainability, low power, and rapid retraining, the CTM is the superior choice.