Cognitive Radio AMC Simulator

An end-to-end simulation and live deployment pipeline for Automatic Modulation Classification (AMC) using a Deep Convolutional Neural Network (CNN).

This project bypasses traditional hand-crafted statistical feature engineering by training a deep network to directly extract phase and amplitude variations from raw In-Phase (I) and Quadrature (Q) time-series data. The system successfully identifies seven distinct digital modulation schemes across heavily degraded Additive White Gaussian Noise (AWGN) channels.

---

The Core Challenge & The "128-QAM vs 256-QAM" Anomaly

In Automatic Modulation Classification, high-frequency signals are observed over microscopic time windows. In this setup, each signal frame consists of exactly 128 samples. Generated at 8 Samples Per Symbol (SPS) to capture waveform curvature, the AI is constrained to look at a rigid window of just 16 symbols at a time.

When classifying dense constellations, this physical window limit introduces a classic geometric anomaly: the 128-QAM constellation grid perfectly overlaps the inner core coordinates of the 256-QAM grid. If a random 16-symbol sampling of a 256-QAM signal happens to land entirely within this shared inner region, a single-frame classifier lacks the "outer edge" data points required to make an accurate distinction. Consequently, a baseline model struggles, splitting its confidence down the middle and misclassifying clean +20dB 256-QAM signals as 128-QAM.

The Solution: Temporal Majority Voting

To solve this physical constraint for real-time deployment, the live simulator implements a Batch Majority Vote Engine. Instead of passing a single isolated frame to the AI, the engine generates a continuous block of 1,000 independent frames simultaneously in memory. The entire block is batch-processed through the neural network in parallel. By tallying the 1,000 separate predictions, the system performs temporal averaging. This ensures that the network catches enough outer-edge symbol placements across the entire batch to reliably isolate high-order schemes, effectively stabilizing the decision boundary and bypassing the 16-symbol physical limitation.

---

Technical Architecture

The project is structurally split into the original offline DSP/training pipeline and the live deployed inference dashboard.

1. Digital Signal Processing & Dataset Generation (dataset_generator.py)

To build the data foundation (147,000 total frames), a synthetic RF environment was engineered from scratch:

• Pulse Shaping: A 33-tap Root-Raised-Cosine (RRC) filter ($\alpha = 0.35$, $SPS = 8$) is applied to restrict infinite signal bandwidth and prevent Inter-Symbol Interference (ISI). Energy normalization is enforced to maintain the integrity of downstream SNR calculations.
• Channel Modeling: Real-world channel degradation is simulated using a parameterized Additive White Gaussian Noise (AWGN) engine across 21 distinct noise levels ranging from -20dB (completely obscured by thermal noise) to +20dB (crystal clear).

2. Deep Learning Engine (train_model.py, ai_inference.py)

A custom 1D Deep CNN functions as an automated phase and amplitude detector:

• Cascaded Filter Blocks: Features a three-block architecture utilizing 64, 128, and 256 filters respectively to capture localized high-frequency voltage variations before mapping broader geometric constellation patterns.
• Regularization & Normalization: Strict Batch Normalization layers are integrated between every convolutional layer. This scales internal activations, preventing dense QAM voltage boundaries from degrading deeper in the network. A 50% Dropout layer stabilizes the dense classification layers against memorizing high-frequency background static.
• Performance: The model achieves a peak test accuracy of 86.40% on unseen validation data, plateauing perfectly as the noise floor drops. At extreme noise levels (-20dB), the model hovers precisely at a baseline of $\sim 14.2%$ (matching the $1/7$ random guess probability), proving it learns actual physical patterns rather than memorizing static.

---

Repository Structure

Project 1 - AMC with DL/
├── amc_deep_cnn_model.h5       # Saved Deep CNN weights and trained model architecture
├── app.py                      # Live native Streamlit frontend dashboard and DSP synthesis loop
├── ai_inference.py             # Optimized parallel TensorFlow inference wrapper
└── research_and_training/      # Core development environment and historical pipeline
    ├── dataset_generator.py    # Raw DSP signal synthesis script (Generates 147k frame baseline)
    ├── train_model.py          # Upgraded deep CNN model architecture and Keras training loop
    ├── evaluate_model.py       # Metrics evaluator and Matplotlib accuracy vs SNR plotter
    └── AMC_DL_report.pdf       # Technical whitepaper detailing the math, anomalies, and results

---

Setup & Installation

1. Environment Configuration

Clone the repository and verify you are operating within a virtual environment:

git clone [https://github.com/yourusername/Project-1-AMC-with-DL.git](https://github.com/yourusername/Project-1-AMC-with-DL.git)
cd Project-1-AMC-with-DL
python -m venv .venv

(Note: On Windows use .venv\Scripts\activate, on Mac/Linux use source .venv/bin/activate)

2. Install Dependencies

Install the required packages. The setup utilizes standard data science, deep learning, and plotting libraries:

pip install numpy tensorflow streamlit plotly scipy scikit-learn matplotlib

---

How to Run the Live Simulator

Launch the reactive dashboard directly from your terminal:

streamlit run app.py

The server will initialize locally (typically at http://localhost:8501).

Using the App:

1. Configure Parameters: Use the left sidebar controls to select a target modulation scheme (e.g., 256-QAM) and set the channel noise via the SNR slider.
2. Execute Transmission: Click the Transmit & Analyze button. The DSP engine will generate 1,000 frames in RAM, stream the tensor batch through the TensorFlow model, run the majority vote, and output the prediction alongside time-averaged confidence metrics.
3. Analyze Geometry: Toggle the theme engine natively via the top-right Streamlit settings button. The interactive Plotly constellation graph will instantly adjust its coordinate colors, allowing you to visually inspect the geometric scattering of the I/Q samples under the selected noise conditions.

---

Project Contributors

This simulator was built as a collaborative Signal Intelligence and Deep Learning project:

• Shreyansh Yadav

  • DSP Engineering: Designed the mathematical dataset pipeline (dataset_generator.py), implementing custom Root-Raised-Cosine (RRC) pulse shaping and real-world AWGN channel degradation to synthesize the 147,000-frame baseline.
  • Frontend Architecture: Built the live Streamlit dashboard (app.py), integrating dynamic Plotly visualizations for real-time I/Q constellation mapping.
  • Inference Logic: Developed the Temporal Majority Voting loop, allowing the simulator to process 1,000 parallel frames to successfully bypass the 16-symbol physical limitation on dense QAM grids.

• Shrinidhi Walvekar

  • Deep Learning Pipeline: Architected and trained the 1D Deep CNN (train_model.py), engineering the 3-block cascaded filter design and tuning the heavy Batch Normalization layers required to extract microscopic phase shifts from static.
  • Evaluation & Metrics: Built the evaluation scripts (evaluate_model.py) to chart the model's accuracy against decreasing Signal-to-Noise Ratios, proving the network's baseline effectiveness.
  • Documentation: Authored the comprehensive technical whitepaper (AMC_DL_report.pdf), formally documenting the network's architecture, the 128-QAM vs. 256-QAM geometric overlap anomaly, and the final waterfall performance curves.