2D_of_IDA.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "BT9cbnS2k31G"
      },
      "outputs": [],
      "source": [
        "import plotly.express as px\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import seaborn as sns # I added this\n",
        "sns.axes_style('whitegrid');\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, cohen_kappa_score\n",
        "import seaborn as sn\n",
        "import scipy.io as sio\n",
        "import os\n",
        "\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import time\n",
        "import seaborn as sn\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CwOSmbpWmqIc"
      },
      "source": [
        "## Read the Data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "K-7UFr7BVADs"
      },
      "outputs": [],
      "source": [
        "def second_step(X, orgin, numComponents):\n",
        "  # standardize the features\n",
        "\n",
        "  sc = StandardScaler()\n",
        "  #X_std = sc.fit_transform(X)\n",
        "  #orgin_std = sc.fit_transform(orgin)\n",
        "\n",
        "  # Calculate the covariance matrix first\n",
        "  \n",
        "  correlation_matrix = np.corrcoef(orgin.T)\n",
        "  #covariance_matrix1 = np.cov(orgin.T)\n",
        "  covariance_matrix = np.cov(X.T)   # The result is a Positive semidefinite matrix\n",
        "  print(correlation_matrix.shape, covariance_matrix.shape)\n",
        "  final_matrix = covariance_matrix - correlation_matrix\n",
        "  print(max(pd.DataFrame(final_matrix)))\n",
        "  # Eigendecomposition of the covariance\n",
        "  eigen_values, eigen_vectors = np.linalg.eig(final_matrix)\n",
        "  # Calculate the variance explained on each of those components\n",
        "  variance_explained = [(i/sum(eigen_values))*100 for i in eigen_values]\n",
        "  # Calculate the cumulative sum of variance explained\n",
        "  cumulative_variance_explained = np.cumsum(variance_explained)\n",
        "  #Taking two components and create a projection matrix\n",
        "  projection_matrix = (eigen_vectors.T[:][:numComponents]).T\n",
        "  \n",
        "  X_IDA1 = X.dot(projection_matrix)\n",
        "\n",
        "  return X_IDA1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "sWNG5-EPqqNC"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "def extract_pixels(X, y):\n",
        "  #q = X.reshape(-1, X.shape[2])\n",
        "  df = pd.DataFrame(data = X)\n",
        "  df = pd.concat([df, pd.DataFrame(data = y.ravel())], axis=1)\n",
        "  df.columns= [f'band{i}' for i in range(1, 1+X.shape[1])]+['class']\n",
        "\n",
        "  return df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "al_HW9g4qstk"
      },
      "outputs": [],
      "source": [
        "from skimage.morphology import reconstruction\n",
        "from sklearn.preprocessing import QuantileTransformer\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "def IDA(X1, y1, band_no, numComponents):\n",
        "    \n",
        "  df = extract_pixels(X1, y1)\n",
        "  X = df.iloc[:, :-1]\n",
        "  y = df.iloc[:, -1]\n",
        "\n",
        "  X_mean = X\n",
        "  X_mean['mean'] = X_mean.mean(axis=1)\n",
        "  Avr = [X_mean['mean']]\n",
        "  rep_Avr = np.repeat(Avr, band_no)\n",
        "  rep_Avr =np.reshape(rep_Avr, (-1,band_no))\n",
        "  main_X = X.iloc[:, :-1]\n",
        "  seed = main_X - rep_Avr\n",
        "  dilated = reconstruction(seed.values, main_X.values)\n",
        "  hdome = main_X - dilated\n",
        "  X = second_step(hdome,X.iloc[:, :-1], numComponents)\n",
        "  scaler = QuantileTransformer(n_quantiles=15, random_state=0,output_distribution='normal') #\n",
        "  scaler = scaler.fit_transform(X)\n",
        " \n",
        "  \n",
        "  return scaler, y "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "id": "o4iT92t-6cTd"
      },
      "outputs": [],
      "source": [
        "# Importing the libraries\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "\n",
        "# Importing the dataset\n",
        "dataset = pd.read_csv('aa.csv')\n",
        "Xx = dataset.iloc[:, 1:15].values\n",
        "yy = dataset.iloc[:, 15].values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V_wSoA-orcF2",
        "outputId": "97396daa-50ae-45ee-93a7-68e5648c048f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(14, 14) (14, 14)\n",
            "13\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((158, 6), (158,))"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ],
      "source": [
        "import time\n",
        "numComponents = 6\n",
        "band_no = Xx.shape[1]\n",
        "K = numComponents  # The target number of bands\n",
        "training_start_time = time.time()\n",
        "X1, y1 = IDA(Xx,yy, band_no, numComponents)\n",
        "training_end_time = time.time()\n",
        "X1.shape, y1.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I_i2IpZ-tzYQ",
        "outputId": "a22f858a-7313-44af-80b6-98dc6b51f97d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "preprocessing time :  0.019751787185668945\n"
          ]
        }
      ],
      "source": [
        "print(\"preprocessing time : \", training_end_time - training_start_time )\n",
        "preprocessing_time = training_end_time - training_start_time "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from matplotlib import pyplot\n",
        "pyplot.figure(figsize=(7,5))\n",
        "pyplot.hist(X1[:,:], bins=25)\n",
        "pyplot.suptitle(\"Main Dataset\")\n",
        "pyplot.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 356
        },
        "id": "gaXTQr_jr6hc",
        "outputId": "c1a403c9-4ddc-4115-f382-00b54bd07207"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pyplot.figure(figsize=(7,5))\n",
        "c = pyplot.boxplot(X1[:,:])\n",
        "top_points = c[\"fliers\"][0].get_data()[1]\n",
        "pyplot.boxplot(X1[:,:])\n",
        "pyplot.suptitle(\"Main Dataset\")\n",
        "pyplot.show()\n",
        "top_points"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 373
        },
        "id": "zvf23GJysCBt",
        "outputId": "4f95aa11-6a9c-42fd-c56d-a54ba36aee36"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-5.19933758,  5.19933758])"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "machine_shape": "hm",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}