classification_by_cwt_cnn_code_ipynb.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "classification by cwt cnn code. ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Aasb38ZnGxxz"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import sklearn\n",
        "from sklearn.model_selection import train_test_split\n",
        "print(\"Tensorflow version: \", tf.__version__)\n",
        "print(\"Numpy version: \", np.__version__)\n",
        "print(\"Pandas version: \", pd.__version__)\n",
        "print(\"Scikit-learn version: \", sklearn.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Clone the repo and run current notebook.\n",
        "file = np.load('/content/drive/MyDrive/wavelet_CWRU_data.npz')\n",
        "print(file.files)"
      ],
      "metadata": {
        "id": "wrdLtJ0XsgR_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data = file['data']\n",
        "labels = file['labels']\n",
        "print(data.shape, labels.shape)"
      ],
      "metadata": {
        "id": "jtDy1eKwtG10"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(data[0])\n",
        "print(labels)"
      ],
      "metadata": {
        "id": "LJ9Ar0hMsn69"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "category_labels = np.unique(labels)\n",
        "print(category_labels)"
      ],
      "metadata": {
        "id": "GwqTRLqRtO17"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "labels = pd.Categorical(labels, categories = category_labels).codes"
      ],
      "metadata": {
        "id": "QYTc_6_2tLDd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size = 1000, random_state = 829,\n",
        "                                                                   stratify = labels)\n",
        "# reshape data as input should be three dimensional to a CNN\n",
        "\n",
        "train_data = train_data.reshape(len(train_data),32,32,1)\n",
        "test_data = test_data.reshape(len(test_data),32,32,1)\n",
        "\n",
        "train_labels = to_categorical(train_labels)\n",
        "test_labels = to_categorical(test_labels)\n",
        "\n",
        "# Shuffle data\n",
        "index = np.random.permutation(len(train_labels))\n",
        "trian_data, trian_labels = train_data[index], train_labels[index]\n",
        "\n",
        "print(train_data.shape, train_labels.shape, test_data.shape, test_labels.shape )"
      ],
      "metadata": {
        "id": "YI7qZL1Mtuvf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "ZOny4xPUxw_n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "demo_model = Sequential([\n",
        "    layers.Conv2D(32,3,activation= 'relu', input_shape = (32,32,1)),\n",
        "    layers.MaxPool2D(2),\n",
        "    layers.Conv2D(32,4,activation = 'relu'),\n",
        "    layers.MaxPool2D(2),\n",
        "#    layers.LSTM(32, activation = \"tanh\", return_sequences = True),\n",
        "    #layers.LSTM(32, activation = \"tanh\"),\n",
        "    layers.Flatten(),\n",
        "    layers.Dense(128,activation = 'relu'),\n",
        "    layers.Dense(96, activation = 'relu'),\n",
        "    layers.Dense(10 ,activation ='softmax')\n",
        "])\n",
        "demo_model.summary()"
      ],
      "metadata": {
        "id": "sUvnALByt2j8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_compiled_model():\n",
        "    model = Sequential([\n",
        "    layers.Conv2D(32,3,activation= 'relu', input_shape = (32,32,1)),\n",
        "    layers.MaxPool2D(2),\n",
        "    layers.Conv2D(32,4,activation = 'relu'),\n",
        "    layers.MaxPool2D(2),\n",
        "    #layers.LSTM(32, activation = \"tanh\", return_sequences = True),\n",
        "#    layers.LSTM(32, activation = \"tanh\"),\n",
        "    layers.Flatten(),\n",
        "    layers.Dense(128,activation = 'relu'),\n",
        "    layers.Dense(96, activation = 'relu'),\n",
        "    layers.Dense(10,activation= 'softmax')\n",
        "    ])\n",
        "    model.compile(loss = 'categorical_crossentropy', optimizer = tf.keras.optimizers.Adam(learning_rate= 0.001), \n",
        "                  metrics= ['accuracy'])\n",
        "    return model"
      ],
      "metadata": {
        "id": "1bQmrOc2ty8q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "res = np.empty(10)\n",
        "res[:] = np.nan\n",
        "for i in range(10):\n",
        "    model = create_compiled_model()\n",
        "    history = model.fit(train_data, train_labels, epochs = 100, batch_size = 128, verbose = 0)    # Verbosity is set to zero\n",
        "    res[i] = model.evaluate(test_data, test_labels, batch_size = 128, verbose = 0)[1]            # Verbosity is set to zero\n",
        "    print('Loop iteration %d, Accuracy: %4.4f' % (i+1, res[i]))\n",
        "    if res[i]>=np.max(res[:(i+1)]):\n",
        "        best_model = model"
      ],
      "metadata": {
        "id": "j9yUv05TuhA1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('Average accuracy:%4.4f'%(np.mean(res))) # After running the model 10 times\n",
        "print(\"Best accuracy: %4.4f\"%(np.max(res)))\n",
        "print(\"Worst accuracy: %4.4f\"%(np.min(res)))\n",
        "print('Standard deviation: %4.4f' % (np.std(res)))"
      ],
      "metadata": {
        "id": "8GMZ_bneuzqc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "prediction = best_model.predict(test_data)\n",
        "prediction_labels = list([])\n",
        "for each_prediction in prediction:\n",
        "    prediction_labels.append(list(each_prediction).index(max(each_prediction)))\n",
        "from sklearn.metrics import confusion_matrix\n",
        "true_labels = np.argmax(test_labels, axis = 1)\n",
        "matrix = confusion_matrix(true_labels, prediction_labels)\n",
        "import seaborn as sns\n",
        "matrix = pd.DataFrame(matrix)\n",
        "plt.figure()\n",
        "sns.heatmap(matrix, annot= True, fmt = \"d\",\n",
        "           xticklabels = category_labels,\n",
        "           yticklabels = category_labels, cmap = \"Blues\", cbar = False)\n",
        "plt.xticks(rotation = 90)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "zNdBwgLvuyzA"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}