ad_time_series_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resample Time-Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z:\\Descargas\\CSV_DATA\\0.csv 857\n",
      "Z:\\Descargas\\CSV_DATA\\1015.csv 832\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from glob import glob\n",
    "\n",
    "def get_shortest_ts():\n",
    "    files = glob('Z:\\Descargas\\CSV_DATA\\*.csv')\n",
    "    min_samples = 999999999999\n",
    "    file_min = None\n",
    "    for file in files:\n",
    "        df = pd.read_csv(file)\n",
    "        row_count = df.shape[0]\n",
    "        if row_count < min_samples:\n",
    "            min_samples = row_count\n",
    "            file_min = file\n",
    "            print(file, str(row_count))\n",
    "            #if min_samples == 832:\n",
    "            #    break\n",
    "    return min_samples, file_min\n",
    "\n",
    "get_shortest_ts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/composite.PNG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "from glob import glob\n",
    "import pandas as pd\n",
    "\n",
    "def resample_data():\n",
    "    size = 832\n",
    "    files = glob('Z:\\Descargas\\CSV_DATA\\*.csv')\n",
    "    for file in files:\n",
    "        df = pd.read_csv(file)\n",
    "        col_names = ('Flow rate', 'Pressure')\n",
    "        col_names = ('Flow rate', 'Zone9_Pressure', 'Zone16_Pressure', 'Zone17_Pressure', 'Zone24_Pressure')\n",
    "        cols = [col for col in df if col.endswith(col_names)]    \n",
    "        resampled_df = pd.DataFrame(signal.resample(df[cols], int(832)))\n",
    "        resampled_df['TOTAL_QUALITY'] = df['TOTAL_QUALITY']\n",
    "        resampled_df.to_csv(file.replace('CSV_DATA', 'CSV_DATA_RESAMPLED'))\n",
    "        \n",
    "resample_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FROM 3D to 2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from glob import glob\n",
    "import pandas as pd\n",
    "         \n",
    "def convert_ts_into_2D():\n",
    "    files = glob('Z:\\Descargas\\CSV_DATA_RESAMPLED\\*.csv')\n",
    "    for file in files:\n",
    "        df = pd.read_csv(file)\n",
    "        df = df.loc[:, ~df.columns.str.contains('^Unnamed')].T\n",
    "        series = None\n",
    "        for index, row in df.iterrows():\n",
    "            if index == 'TOTAL_QUALITY':\n",
    "                series = pd.concat([series, pd.Series(int(row[0]), dtype=object)])               \n",
    "            else:\n",
    "                series = pd.concat([series, row])               \n",
    "         \n",
    "        #series = series.reset_index(drop=True)  \n",
    "        new_df = pd.DataFrame().append(pd.Series(list(series)), ignore_index=True)\n",
    "        # append series into csv\n",
    "        output_file = 'Z:\\\\Descargas\\\\resampled_2d_data.csv'\n",
    "        if not os.path.isfile(output_file):\n",
    "            new_df.to_csv(output_file)\n",
    "        else:\n",
    "            new_df.to_csv(output_file, mode='a', header=False)            \n",
    "        \n",
    "convert_ts_into_2D()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scale the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "df = pd.read_csv('Z:\\\\Descargas\\\\resampled_2d_data.csv')\n",
    "df = df.loc[:, ~df.columns.str.contains('^Unnamed')]\n",
    "X = df.iloc[:,:-1]\n",
    "y = df.iloc[:,-1]\n",
    "\n",
    "df = None\n",
    "#dfs = np.split(X, 29, axis=1) # 29 sensors, each sensor 832 columns\n",
    "dfs = np.split(X, 5, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.862.1452&rep=rep1&type=pdf\n",
    "import math\n",
    "    \n",
    "def group_scalling(df):    \n",
    "    Uj = np.mean(df.values)    \n",
    "    Qj2 = np.mean(((df - Uj)**2).values)    \n",
    "    new_df = df.copy() \n",
    "    for col in df:\n",
    "        new_df[col] = (new_df[col] - np.mean(new_df[col])) / math.sqrt(Qj2)      \n",
    "    return new_df \n",
    "\n",
    "scalled_dfs = []\n",
    "for df in dfs: \n",
    "    scalled_df = group_scalling(df)   \n",
    "    scalled_dfs.append(scalled_df)\n",
    "dfs = None\n",
    "    \n",
    "len(scalled_dfs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scalled_df = pd.concat(scalled_dfs, axis=1)\n",
    "scalled_df['target'] = y\n",
    "scalled_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scalled_df.to_csv('Z:\\\\Descargas\\\\resampled_ts_group_scalled.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DETECT ANOMALIES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Target 1 shape: (5055, 4161)\n",
      "Target 0 shape: (4959, 4161)\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "df = pd.read_csv('Z:\\\\Descargas\\\\resampled_ts_group_scalled.csv')\n",
    "df = df.loc[:, ~df.columns.str.contains('^Unnamed')]\n",
    "X = df.iloc[:,:-1]\n",
    "y = df.iloc[:,-1]\n",
    "df = pd.DataFrame(X)\n",
    "df['target'] = y\n",
    "\n",
    "# Divide dataframe depending on target\n",
    "df_correct = df.loc[df['target'] == 1]\n",
    "df_incorrect = df.loc[df['target'] == 0]\n",
    "\n",
    "# Print each target shape\n",
    "print('Target 1 shape: ' + str(df_correct.shape))\n",
    "print('Target 0 shape: ' + str(df_incorrect.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import shuffle\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "df_train, df_test_correct = train_test_split(df_correct, test_size=0.2, random_state=0)\n",
    "df_test_incorrect = df_incorrect\n",
    "\n",
    "X_train = df_train.iloc[:,:-1]\n",
    "X_test_correct = df_test_correct.iloc[:,:-1]\n",
    "X_test_incorrect = df_test_incorrect.iloc[:,:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.29364827120675585\n",
      "2 Principal Components\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.decomposition import PCA\n",
    "from models.model import ReconstructionErrorModel\n",
    "\n",
    "# Fit reconstruction error model with correct data\n",
    "model = ReconstructionErrorModel(X_train, model=PCA(n_components=0.9))\n",
    "\n",
    "# Calculate anomaly threshold with correct data\n",
    "train_errors = model.predict(X_train)\n",
    "threshold = np.mean(train_errors) + (np.std(train_errors) * 3)\n",
    "\n",
    "# Print principal components\n",
    "print(threshold)\n",
    "print('%i Principal Components' % len(model.get_model().explained_variance_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.hist(model.predict(X_train))\n",
    "plt.xlabel('MSE')\n",
    "plt.ylabel('Samples')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.hist(model.predict(X_test_correct))\n",
    "plt.xlabel('MSE')\n",
    "plt.ylabel('Samples')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.hist(model.predict(X_test_incorrect))\n",
    "plt.xlabel('MSE')\n",
    "plt.ylabel('Samples')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0.08"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anomalies with train data 1414\n",
      "Anomalies with test correct data 357\n",
      "Anomalies with test incorrect data 3057\n"
     ]
    }
   ],
   "source": [
    "# Calculate how many train instances are detected as anomalies\n",
    "errors = model.predict(X_train)\n",
    "anomalies = np.where(errors > threshold)[0]\n",
    "print('Anomalies with train data %s' % str(len(anomalies)))\n",
    "\n",
    "# Calculate how many test correct instances are detected as anomalies\n",
    "errors = model.predict(X_test_correct)\n",
    "anomalies = np.where(errors > threshold)[0]\n",
    "print('Anomalies with test correct data %s' % str(len(anomalies)))\n",
    "\n",
    "# Calculate how many test incorrect instances are detected as anomalies\n",
    "errors = model.predict(X_test_incorrect)\n",
    "anomalies = np.where(errors > threshold)[0]\n",
    "print('Anomalies with test incorrect data %s' % str(len(anomalies)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "kernelspec": {
   "display_name": "Python 3",
   "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.2"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 4
}