Digital_Signal_Processing_Error_Prediction_Using_ML.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyP+R5HVVW1VkiKL1iepAcAP",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/neha2801-create/Basket_Game/blob/main/Digital_Signal_Processing_Error_Prediction_Using_ML.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# DSP Error Prediction Using Machine Learning\n",
        "\n",
        "## Problem Statement\n",
        "In Digital Signal Processing (DSP), errors such as noise, distortion, phase shifts, and other anomalies can significantly affect the quality and integrity of signals. Detecting and diagnosing these errors is crucial for maintaining system performance and ensuring high-quality signal processing.\n",
        "\n",
        "The challenge is to identify and classify different types of errors in DSP signals, enabling proactive error handling and system optimization.\n",
        "\n",
        "## Objective\n",
        "The goal of this project is to build a machine learning model that can automatically detect and classify various error types (e.g., noise, distortion, phase shift, or no error) in digital signals based on extracted features. By achieving this, the system can identify signal errors in real-time, improving overall DSP system performance and reducing manual inspection.\n",
        "\n",
        "## Approach\n",
        "\n",
        "### Data Generation\n",
        "1. **Synthetic Signal Data**:\n",
        "   - We generate synthetic DSP signal data to simulate real-world scenarios. Each signal is generated with a random base frequency and amplitude.\n",
        "   - For each generated signal, we introduce a random error type from the following:\n",
        "     - **Noise**: Random Gaussian noise is added to the signal.\n",
        "     - **Distortion**: The signal is distorted by amplifying its values and clipping the extremes.\n",
        "     - **Phase Shift**: A phase shift is applied to the signal to simulate misalignment.\n",
        "     - **No Error**: The signal remains unchanged.\n",
        "\n",
        "2. **Features Extraction**:\n",
        "   - We extract several statistical and frequency-domain features from the generated signal data. These features include:\n",
        "     - **Statistical Features**: Mean, standard deviation, skewness, kurtosis.\n",
        "     - **Frequency-domain Features**: Peak frequency, bandwidth, power spectral density.\n",
        "     - **Time-domain Features**: RMS (root mean square), crest factor, shape factor, impulse factor.\n",
        "   - These features help in distinguishing between clean and error-prone signals.\n",
        "\n",
        "### Model Training\n",
        "1. **Random Forest Classifier**:\n",
        "   - We use a **Random Forest Classifier** to model the relationship between the extracted features and the signal error types.\n",
        "   - The classifier is trained on a labeled dataset, where each sample consists of a set of features and a corresponding label indicating the error type (no error, noise, distortion, or phase shift).\n",
        "\n",
        "2. **Model Evaluation**:\n",
        "   - We evaluate the model using standard machine learning metrics such as accuracy, precision, recall, and F1-score.\n",
        "   - A confusion matrix is used to visualize the model's performance and to identify any misclassifications.\n",
        "\n",
        "### Dashboard for Visualization\n",
        "1. **Error Distribution**: A count plot is used to show the distribution of different error types in the dataset.\n",
        "2. **Feature Importance**: A bar plot visualizes the importance of each feature in predicting the error type, which helps in understanding which features contribute most to the classification task.\n",
        "3. **Confusion Matrix**: A heatmap of the confusion matrix provides insights into the model's classification performance, including misclassifications between error types.\n",
        "4. **Performance Metrics**: A heatmap is used to display various performance metrics (precision, recall, F1-score) for each class (error type).\n",
        "5. **Feature Correlations**: A heatmap is also used to visualize the correlations between different features, providing an understanding of how features relate to each other.\n",
        "\n",
        "## Conclusion\n",
        "The project successfully detects and classifies DSP signal errors using machine learning techniques. By extracting relevant features from the signal and training a Random Forest classifier, the model can accurately identify and classify different types of signal errors. The interactive dashboard provides useful visual insights into the model's performance and the importance of each feature in error prediction.\n",
        "\n",
        "This approach can be applied to various DSP systems where real-time error detection is critical for ensuring signal integrity and system reliability.\n"
      ],
      "metadata": {
        "id": "fN3NtQGQKsfF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pip install numpy pandas matplotlib seaborn scipy scikit-learn plotly ipython\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tg4WIeVrK78I",
        "outputId": "a1064b2f-ffa7-4c06-abdd-6778f4a146fd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (1.26.4)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.11/dist-packages (2.2.2)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n",
            "Requirement already satisfied: seaborn in /usr/local/lib/python3.11/dist-packages (0.13.2)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (1.13.1)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.11/dist-packages (1.6.1)\n",
            "Requirement already satisfied: plotly in /usr/local/lib/python3.11/dist-packages (5.24.1)\n",
            "Requirement already satisfied: ipython in /usr/local/lib/python3.11/dist-packages (7.34.0)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.11/dist-packages (from pandas) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas) (2025.1)\n",
            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas) (2025.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.55.8)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (24.2)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n",
            "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn) (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn) (3.5.0)\n",
            "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.11/dist-packages (from plotly) (9.0.0)\n",
            "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.11/dist-packages (from ipython) (75.1.0)\n",
            "Collecting jedi>=0.16 (from ipython)\n",
            "  Downloading jedi-0.19.2-py2.py3-none-any.whl.metadata (22 kB)\n",
            "Requirement already satisfied: decorator in /usr/local/lib/python3.11/dist-packages (from ipython) (4.4.2)\n",
            "Requirement already satisfied: pickleshare in /usr/local/lib/python3.11/dist-packages (from ipython) (0.7.5)\n",
            "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.11/dist-packages (from ipython) (5.7.1)\n",
            "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from ipython) (3.0.50)\n",
            "Requirement already satisfied: pygments in /usr/local/lib/python3.11/dist-packages (from ipython) (2.18.0)\n",
            "Requirement already satisfied: backcall in /usr/local/lib/python3.11/dist-packages (from ipython) (0.2.0)\n",
            "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.11/dist-packages (from ipython) (0.1.7)\n",
            "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.11/dist-packages (from ipython) (4.9.0)\n",
            "Requirement already satisfied: parso<0.9.0,>=0.8.4 in /usr/local/lib/python3.11/dist-packages (from jedi>=0.16->ipython) (0.8.4)\n",
            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.11/dist-packages (from pexpect>4.3->ipython) (0.7.0)\n",
            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.11/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython) (0.2.13)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n",
            "Downloading jedi-0.19.2-py2.py3-none-any.whl (1.6 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m16.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: jedi\n",
            "Successfully installed jedi-0.19.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install seaborn\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-2CZb1mkLMQL",
        "outputId": "ba671b9d-739c-4ae5-ca8b-4ae481e6d1fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: seaborn in /usr/local/lib/python3.11/dist-packages (0.13.2)\n",
            "Requirement already satisfied: numpy!=1.24.0,>=1.20 in /usr/local/lib/python3.11/dist-packages (from seaborn) (1.26.4)\n",
            "Requirement already satisfied: pandas>=1.2 in /usr/local/lib/python3.11/dist-packages (from seaborn) (2.2.2)\n",
            "Requirement already satisfied: matplotlib!=3.6.1,>=3.4 in /usr/local/lib/python3.11/dist-packages (from seaborn) (3.10.0)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (4.55.8)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.4.8)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (24.2)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (3.2.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.2->seaborn) (2025.1)\n",
            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.2->seaborn) (2025.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib!=3.6.1,>=3.4->seaborn) (1.17.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from scipy import signal\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "import plotly.express as px\n",
        "import plotly.graph_objects as go\n",
        "from IPython.display import display, HTML\n",
        "\n",
        "# Set random seed for reproducibility\n",
        "np.random.seed(42)\n",
        "\n",
        "class DSPErrorPredictor:\n",
        "    def __init__(self):\n",
        "        self.model = RandomForestClassifier(n_estimators=100, random_state=42)\n",
        "        self.data = None\n",
        "        self.X = None\n",
        "        self.y = None\n",
        "        self.y_test = None\n",
        "\n",
        "    def generate_signal_data(self, n_samples=1000):\n",
        "        \"\"\"Generate synthetic DSP signal data with various error patterns\"\"\"\n",
        "        # Time vector\n",
        "        t = np.linspace(0, 1, 100)\n",
        "\n",
        "        # Initialize empty lists for features and labels\n",
        "        signals = []\n",
        "        labels = []\n",
        "\n",
        "        for _ in range(n_samples):\n",
        "            # Generate base signal (clean)\n",
        "            base_freq = np.random.uniform(10, 50)\n",
        "            amplitude = np.random.uniform(0.5, 2.0)\n",
        "            clean_signal = amplitude * np.sin(2 * np.pi * base_freq * t)\n",
        "\n",
        "            # Randomly introduce different types of errors\n",
        "            error_type = np.random.choice(['none', 'noise', 'distortion', 'phase_shift'])\n",
        "\n",
        "            if error_type == 'none':\n",
        "                signal_with_error = clean_signal\n",
        "                label = 0\n",
        "            elif error_type == 'noise':\n",
        "                noise = np.random.normal(0, 0.2, len(t))\n",
        "                signal_with_error = clean_signal + noise\n",
        "                label = 1\n",
        "            elif error_type == 'distortion':\n",
        "                signal_with_error = np.clip(clean_signal * 1.5, -1, 1)\n",
        "                label = 2\n",
        "            else:  # phase_shift\n",
        "                phase_shift = np.random.uniform(0, np.pi/2)\n",
        "                signal_with_error = amplitude * np.sin(2 * np.pi * base_freq * t + phase_shift)\n",
        "                label = 3\n",
        "\n",
        "            # Extract features from the signal\n",
        "            features = self._extract_features(signal_with_error)\n",
        "            signals.append(features)\n",
        "            labels.append(label)\n",
        "\n",
        "        # Convert to numpy arrays\n",
        "        self.X = np.array(signals)\n",
        "        self.y = np.array(labels)\n",
        "\n",
        "        # Create DataFrame\n",
        "        feature_names = ['mean', 'std', 'skew', 'kurtosis', 'peak_freq', 'bandwidth',\n",
        "                        'rms', 'crest_factor', 'shape_factor', 'impulse_factor']\n",
        "        self.data = pd.DataFrame(self.X, columns=feature_names)\n",
        "        self.data['error_type'] = [['none', 'noise', 'distortion', 'phase_shift'][l] for l in self.y]\n",
        "\n",
        "        return self.data\n",
        "\n",
        "    def _extract_features(self, signal_data):\n",
        "        \"\"\"Extract relevant DSP features from the signal\"\"\"\n",
        "        # Statistical features\n",
        "        mean = np.mean(signal_data)\n",
        "        std = np.std(signal_data)\n",
        "        skew = self._calculate_skewness(signal_data)\n",
        "        kurtosis = self._calculate_kurtosis(signal_data)\n",
        "\n",
        "        # Frequency domain features\n",
        "        freqs, psd = signal.welch(signal_data)\n",
        "        peak_freq = freqs[np.argmax(psd)]\n",
        "        bandwidth = np.sum(psd > np.max(psd)/2) * (freqs[1] - freqs[0])\n",
        "\n",
        "        # Time domain features\n",
        "        rms = np.sqrt(np.mean(signal_data**2))\n",
        "        peak = np.max(np.abs(signal_data))\n",
        "        crest_factor = peak / rms\n",
        "        shape_factor = rms / np.mean(np.abs(signal_data))\n",
        "        impulse_factor = peak / np.mean(np.abs(signal_data))\n",
        "\n",
        "        return [mean, std, skew, kurtosis, peak_freq, bandwidth,\n",
        "                rms, crest_factor, shape_factor, impulse_factor]\n",
        "\n",
        "    def _calculate_skewness(self, data):\n",
        "        \"\"\"Calculate skewness of the signal\"\"\"\n",
        "        n = len(data)\n",
        "        mean = np.mean(data)\n",
        "        std = np.std(data)\n",
        "        return np.sum((data - mean)**3) / ((n-1) * std**3)\n",
        "\n",
        "    def _calculate_kurtosis(self, data):\n",
        "        \"\"\"Calculate kurtosis of the signal\"\"\"\n",
        "        n = len(data)\n",
        "        mean = np.mean(data)\n",
        "        std = np.std(data)\n",
        "        return np.sum((data - mean)**4) / ((n-1) * std**4)\n",
        "\n",
        "    def train_model(self):\n",
        "        \"\"\"Train the Random Forest model\"\"\"\n",
        "        X_train, X_test, y_train, y_test = train_test_split(\n",
        "            self.X, self.y, test_size=0.2, random_state=42\n",
        "        )\n",
        "\n",
        "        self.model.fit(X_train, y_train)\n",
        "        self.y_pred = self.model.predict(X_test)\n",
        "        self.y_test = y_test\n",
        "\n",
        "        # Store results for visualization\n",
        "        self.confusion_mat = confusion_matrix(y_test, self.y_pred)\n",
        "        self.classification_rep = classification_report(y_test, self.y_pred, output_dict=True)\n",
        "        self.feature_importance = pd.DataFrame({\n",
        "            'feature': self.data.columns[:-1],\n",
        "            'importance': self.model.feature_importances_\n",
        "        }).sort_values('importance', ascending=False)\n",
        "\n",
        "        return self.classification_rep\n",
        "\n",
        "    def create_dashboard(self):\n",
        "        \"\"\"Create an interactive dashboard for visualization\"\"\"\n",
        "        # Style settings\n",
        "\n",
        "        plt.style.use('ggplot')\n",
        "\n",
        "        # Create subplots\n",
        "        fig = plt.figure(figsize=(20, 12))\n",
        "\n",
        "        # 1. Error Distribution\n",
        "        plt.subplot(231)\n",
        "        sns.countplot(data=self.data, x='error_type')\n",
        "        plt.title('Distribution of Error Types')\n",
        "        plt.xticks(rotation=45)\n",
        "\n",
        "        # 2. Feature Importance\n",
        "        plt.subplot(232)\n",
        "        sns.barplot(data=self.feature_importance.head(5),\n",
        "                   x='importance', y='feature')\n",
        "        plt.title('Top 5 Important Features')\n",
        "\n",
        "        # 3. Confusion Matrix\n",
        "        plt.subplot(233)\n",
        "        sns.heatmap(self.confusion_mat, annot=True, fmt='d',\n",
        "                    xticklabels=['none', 'noise', 'distortion', 'phase_shift'],\n",
        "                    yticklabels=['none', 'noise', 'distortion', 'phase_shift'])\n",
        "        plt.title('Confusion Matrix')\n",
        "\n",
        "        # 4. Performance Metrics\n",
        "        plt.subplot(234)\n",
        "        metrics_df = pd.DataFrame(self.classification_rep).drop(['support'], axis=0)\n",
        "        sns.heatmap(metrics_df, annot=True, fmt='.2f')\n",
        "        plt.title('Classification Metrics')\n",
        "\n",
        "        # 5. Feature Correlations\n",
        "        plt.subplot(235)\n",
        "        correlation_matrix = self.data.drop('error_type', axis=1).corr()\n",
        "        sns.heatmap(correlation_matrix, annot=False)\n",
        "        plt.title('Feature Correlations')\n",
        "\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "        # Print classification report\n",
        "        print(\"\\nDetailed Classification Report:\")\n",
        "        print(classification_report(self.y_pred, self.y_test, target_names=['none', 'noise', 'distortion', 'phase_shift']))\n",
        "\n",
        "# Example usage and dashboard creation\n",
        "predictor = DSPErrorPredictor()\n",
        "data = predictor.generate_signal_data(n_samples=1000)\n",
        "predictor.train_model()\n",
        "predictor.create_dashboard()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "664OXov9Ks7f",
        "outputId": "a34d777a-2823-440d-83db-f417ae848053"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/scipy/signal/_spectral_py.py:600: UserWarning: nperseg = 256 is greater than input length  = 100, using nperseg = 100\n",
            "  freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x1200 with 8 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Detailed Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "        none       0.74      0.69      0.71        54\n",
            "       noise       1.00      1.00      1.00        45\n",
            "  distortion       0.96      0.95      0.95        56\n",
            " phase_shift       0.66      0.73      0.69        45\n",
            "\n",
            "    accuracy                           0.84       200\n",
            "   macro avg       0.84      0.84      0.84       200\n",
            "weighted avg       0.84      0.84      0.84       200\n",
            "\n"
          ]
        }
      ]
    }
  ]
}