Code_PU_Dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "from scipy.io import loadmat\n",
    "from numpy import asarray\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy import signal\n",
    "import scipy\n",
    "import re\n",
    "import os\n",
    "import pandas as pd\n",
    "import pywt\n",
    "from scipy.fftpack import fft\n",
    "from warnings import warn\n",
    "from sklearn import metrics\n",
    "\n",
    "import warnings \n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function for FFT\n",
    "\n",
    "def apply_fft(x, fs, num_samples):\n",
    "    f = np.linspace(0.0, (fs/2.0), num_samples//2)\n",
    "    freq_values = fft(x)\n",
    "    freq_values = 2.0/num_samples * np.abs(freq_values[0:num_samples//2])\n",
    "    return f, freq_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# @@@ Function to create dataset from raw vibration signals @@@\n",
    "# The function processes .mat vibration data files and do segmentation of vibration signals according to \n",
    "# desired length of the input segment \"num_samples\".\n",
    "# The function returns segmented vibration signlas \"segmented_data\" along with their classes \" Class_\" . \n",
    "\n",
    "def make_dataset(data_src, num_samples, class_):\n",
    "    files = glob.glob(data_src)\n",
    "    files = np.sort(files)\n",
    "    data = loadmat(files[0])\n",
    "    keysList = sorted(data.keys())\n",
    "    key = keysList[0]\n",
    "    drive_end_data = data[key]['Y'][0][0][0][6][2]\n",
    "    drive_end_data = drive_end_data.reshape(-1)\n",
    "    num_segments = np.floor(len(drive_end_data)/num_samples)\n",
    "    slices = np.split(drive_end_data[0:int(num_segments*num_samples)], num_samples)\n",
    "    slices = np.array(slices).reshape(int(num_segments), num_samples)\n",
    "    segmented_data = slices\n",
    "    files = files[1:]\n",
    "    for file in files:\n",
    "        data = loadmat(file)\n",
    "        keysList = sorted(data.keys())\n",
    "        key = keysList[0]\n",
    "        drive_end_data = data[key]['Y'][0][0][0][6][2]\n",
    "        drive_end_data = drive_end_data.reshape(-1)\n",
    "        num_segments = np.floor(len(drive_end_data)/num_samples)\n",
    "        slices = np.split(drive_end_data[0:int(num_segments*num_samples)], num_samples)\n",
    "        slices = np.array(slices).reshape(int(num_segments), num_samples)\n",
    "        segmented_data = np.concatenate( (segmented_data, slices) , axis=0, out=None)\n",
    "    \n",
    "    segmented_data = np.unique(segmented_data, axis= 0) # remove duplicates\n",
    "    np.random.shuffle( segmented_data) # suffule the data\n",
    "    Class_ = np.ones(len(segmented_data))*class_\n",
    "   \n",
    "    \n",
    "    return segmented_data, Class_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "==========================================================================================================================\n",
    "# Dataset Creatioin:\n",
    "=========================================================================================================================== "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grouping vibration signals in required folders to  generate datasets\n",
    " \n",
    "Link to download the PU dataset: https://mb.uni-paderborn.de/kat/forschung/kat-datacenter/bearing-datacenter/data-sets-and-download <br>\n",
    "After downloading the dataset, vibration signals to be grouped according to their operational conditions/properties in 4 folders (corresponding to number of operational classes in the dataset: 1 normal class and 3 faulty classes) with below folder names:\n",
    "\n",
    "1.\tHealthy\n",
    "2.\tIR&OR\n",
    "3.\tIR\n",
    "4.\tOR\n",
    "\n",
    "*IR&OR =  Inner Race faults and Outter Race faults <br>\n",
    "*IR = Inner Race fault <br>\n",
    "*OR = Outer Race faults <br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_samples = 12800 # Set required length of input vibration segment \"number of data points\"\n",
    "###########################################\n",
    "fs = 64000; # Sampling freq."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = (r\"C:\\dataset\") # path were the folders contain vibration signals are located.\n",
    "\n",
    "cls_1 = 'Healthy/*'; cls_2 = 'IR&OR/*'; cls_3 = 'IR/*'; cls_4 = 'OR/*'\n",
    "\n",
    "norm, y_norm   = make_dataset(os.path.join(data_path, cls_1), num_samples, 0)\n",
    "defc1, y_defc1 = make_dataset(os.path.join(data_path, cls_2), num_samples, 1)\n",
    "defc2, y_defc2 = make_dataset(os.path.join(data_path, cls_3), num_samples, 2)\n",
    "defc3, y_defc3 = make_dataset(os.path.join(data_path, cls_4), num_samples, 3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.concatenate( (norm, defc1, defc2, defc3) , axis=0, out=None)\n",
    "Y = np.concatenate( (y_norm, y_defc1, y_defc2, y_defc3), axis=0, out=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "==========================================================================================================================\n",
    "# Feature Extraction:\n",
    "=========================================================================================================================== "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#####INPUTS / Parameters #############\n",
    "wavelet_function = \"db4\"\n",
    "num_levels = 5 # k parameter\n",
    "m = 5 # m parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wavelet Packet Transform and feature extraction:\n",
    "\n",
    "num_features = 2**num_levels\n",
    "features = np.repeat(np.nan, len(X)*m*num_features).reshape(len(X),m*num_features)\n",
    "\n",
    "for i in range(len(X)):    \n",
    "    wp = pywt.WaveletPacket(X[i], wavelet = wavelet_function, maxlevel = num_levels) # Wavelet packet transformation\n",
    "    packet_names = [node.path for node in wp.get_level(num_levels, \"natural\")]\n",
    "    for j in range(num_features):\n",
    "        new_wp = pywt.WaveletPacket(data = None, wavelet = wavelet_function, maxlevel = num_levels)\n",
    "        new_wp[packet_names[j]] = wp[packet_names[j]].data\n",
    "        reconstructed_signal = new_wp.reconstruct(update = False) # Signal reconstruction from wavelet packet coefficients\n",
    "        f, c = apply_fft(reconstructed_signal, fs, len(reconstructed_signal))\n",
    "        z = abs(c)\n",
    "        \n",
    "        # Find  m  highest amplitudes of the spectrum and their corresponding frequencies:\n",
    "        maximal_idx = np.argpartition(z, -m)[-m:]\n",
    "        high_amp = z[maximal_idx] \n",
    "        high_freq = f[maximal_idx]\n",
    "        feature = high_amp*high_freq \n",
    "        \n",
    "        l = 0\n",
    "        for f in feature:\n",
    "            features[i,j*m+l] = f\n",
    "            l = l+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "===========================================================================================================================\n",
    "# Classification:\n",
    "==========================================================================================================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import seaborn as sns\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import roc_curve\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = pd.Categorical(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size = 0.2, \n",
    "                                                    shuffle = True, stratify = labels, random_state = 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "train_data_scaled = scaler.fit_transform(X_train)\n",
    "test_data_scaled = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf_RF = RandomForestClassifier(criterion='entropy', max_features = 1, min_samples_leaf=1, min_samples_split=2, \n",
    "                                max_depth=20, n_estimators=200)\n",
    "clf_RF.fit(train_data_scaled, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of Samples = 12800 /  k = 5 /  m = 5\n",
      "ROC AUC = 1.000\n",
      "F1 Score = 0.996875\n",
      "Accuracy = 99.688 %\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_predictions = clf_RF.predict(test_data_scaled)\n",
    "test_confu_matrix = confusion_matrix(y_test, test_predictions)\n",
    "fault_type = ['C1','C2','C3','C4']\n",
    "plt.figure(1,figsize=(18,8))\n",
    "sns.heatmap(test_confu_matrix, annot= True,fmt = \"d\",\n",
    "xticklabels=fault_type, yticklabels=fault_type, cmap = \"Blues\")\n",
    "plt.xlabel('Predicted Calss')\n",
    "plt.ylabel('True Class')\n",
    "plt.ylabel('True')\n",
    "Accuracy = metrics.accuracy_score(y_test, test_predictions)\n",
    "F1_score = metrics.f1_score(y_test, test_predictions, average='micro')\n",
    "probs = clf_RF.predict_proba(test_data_scaled)\n",
    "lr_auc = roc_auc_score(y_test, probs, multi_class='ovr')\n",
    "print(\"No. of Samples =\", num_samples, \"/  k =\", num_levels, \"/  m =\", m, )\n",
    "print('ROC AUC = %.3f' % (lr_auc))\n",
    "print(\"F1 Score =\", F1_score)\n",
    "print(\"Accuracy = %.3f\" % (Accuracy*100), \"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}