First_cut_approach_Case_study_1#PdM#07_04_2022.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predictive Maintenance using Machine Learning\n",
    "\n",
    "The economic potential of deployment of Artificial Intelligence (AI) has been widely highlighted by policy makers, technologists, academics and civil society around the world. In India, the National Strategy on Artificial Intelligence (NSAI) released by NITI Aayog in 2018 highlights the potential of AI to solve social challenges faced by its citizens in areas such agriculture, health and education, in addition to the pure economic returns that are brought by this technology. \n",
    "\n",
    "<p>Now a days most of the industries are adopting Industry 4.0 Technologies for numerous number of benefits.\n",
    "Industries that invest in Industry 4.0 solutions can increase efficiency, boost collaboration between departments, enable predictive and prescriptive analytics, and allow people including operators, managers, and executives to more fully leverage real-time data and intelligence to make better decisions while managing their day-to-day responsibilities.</p>\n",
    "\n",
    "<p> Here we will explore the application of Machine Learning in Predictive Maintenance. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem Description\n",
    "A major problem faced by businesses in asset-heavy industries such as manufacturing is the significant costs that are associated with delays in the production process due to mechanical problems. Most of these businesses are interested in predicting these problems in advance so that they can proactively prevent the problems before they occur which will reduce the costly impact caused by downtime.\n",
    "\n",
    "The business problem for this example is about predicting problems caused by component failures such that the question \"What is the probability that a machine will fail in the near future (within 1 day or 7 days) due to a failure of a certain component?\" can be answered.  The problem is formatted as a multi-class classification problem and a machine learning algorithm is used to create the predictive model that learns from historical data collected from machines. \n",
    "\n",
    "Based on the health of an equipment in the past, future point of failure can be predicted in Predictive Maintenance. Thus, replacement of parts can be scheduled just before the actual failure.\n",
    "\n",
    "Traditionally, predictive maintenance is being done using rule based techniques. With the advent of connected sensors (IoT), data from equipment is continuously collected and fed to Machine Learning based systems to predict its future health.\n",
    "\n",
    "<p>In the following sections, we go through the steps of implementing such a model which are feature engineering, label construction, training  and evaluation. First, we start by explaining the data sources in the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploratory data analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Sources\n",
    "\n",
    "The dataset is available in Kaggle (link:         https://www.kaggle.com/datasets/arnabbiswas1/microsoft-azure-predictive-maintenance ). This dataset was available as a part of Azure AI Notebooks for Predictive Maintenance.\n",
    "\n",
    "\n",
    "### Dataset Description:\n",
    "There are 5 CSV files consisting of:\n",
    "\n",
    "- <b>Telemetry Time Series Data (PdM_telemetry.csv):</b> Telemetry is the automated communication processes from multiple data sources. It consists of hourly average of voltage, rotation, pressure, vibration collected from 100 machines for the year 2015.\n",
    "\n",
    "\n",
    "- <b>Error (PdM_errors.csv):</b> These are errors encountered by the machines while in operating condition. Since, these errors don't shut down the machines, these are not considered as failures. The error date and times are rounded to the closest hour since the telemetry data is collected at an hourly rate.\n",
    "\n",
    "\n",
    "- <b>Maintenance (PdM_maint.csv):</b> If a component of a machine is replaced, that is captured as a record in this table. Components are replaced under two situations:\n",
    "\n",
    "    During the regular scheduled visit, the technician replaced it (Proactive Maintenance)\n",
    "    A component breaks down and then the technician does an unscheduled maintenance to replace the       component (Reactive Maintenance). This is considered as a failure and corresponding data is           captured under Failures. Maintenance data has both 2014 and 2015 records. This data is rounded to     the closest hour since the telemetry data is collected at an hourly rate.\n",
    "    \n",
    "\n",
    "- <b>Failures (PdM_failures.csv):</b> Each record represents replacement of a component due to failure. This data is a subset of Maintenance data. This data is rounded to the closest hour since the telemetry data is collected at an hourly rate.\n",
    "\n",
    "\n",
    "- <b>Metadata of Machines (PdM_Machines.csv):</b> Model type & age of the Machines.\n",
    "\n",
    "\n",
    "The data comes from 4 different sources which are real-time telemetry data collected from machines, error messages, historical maintenance records that include failures and machine information such as type and age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing libraries\n",
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "matplotlib.style.use(\"Solarize_Light2\")\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Loading all the dataset using Pandas library\n",
    "import pandas as pd\n",
    "\n",
    "telemetry = pd.read_csv('PdM_telemetry.csv')\n",
    "errors = pd.read_csv('PdM_errors.csv')\n",
    "maint = pd.read_csv('PdM_maint.csv')\n",
    "failures = pd.read_csv('PdM_failures.csv')\n",
    "machines = pd.read_csv('PdM_machines.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating some utilities functions:\n",
    "#https://www.kaggle.com/datasets/arnabbiswas1/microsoft-azure-predictive-maintenance/code\n",
    "\n",
    "def check_null(df):\n",
    "    \"\"\"\n",
    "    Returns percentage of rows containing missing data\n",
    "    \"\"\"\n",
    "    return df.isna().sum() * 100/len(df)\n",
    "\n",
    "\n",
    "def get_missing_dates(series, start_date, end_date, freq=\"D\"):\n",
    "    \"\"\"\n",
    "    Returns the dates which are missing in the series\n",
    "    date_sr between the start_date and end_date\n",
    "    \n",
    "    series: Series consisting of date\n",
    "    start_date: Start date in String format\n",
    "    end_date: End date in String format\n",
    "    \"\"\"\n",
    "    return pd.date_range(\n",
    "        start=start_date, end=end_date, freq=freq).difference(series)\n",
    "\n",
    "\n",
    "def check_duplicate(df, subset):\n",
    "    \"\"\"\n",
    "    Returns if there are any duplicate rows in the DataFrame.\n",
    "    \n",
    "    df: DataFrame under consideration\n",
    "    subset: Optional List of feature names based on which \n",
    "            duplicate rows are being identified. \n",
    "    \"\"\"\n",
    "    if subset is not None: \n",
    "        return df.duplicated(subset=subset, keep=False).sum()\n",
    "    else:\n",
    "        return df.duplicated(keep=False).sum()\n",
    "\n",
    "\n",
    "def create_date_features(source_df, target_df, feature_name):\n",
    "    '''\n",
    "    Create new features related to dates\n",
    "    \n",
    "    source_df : DataFrame consisting of the timestamp related feature\n",
    "    target_df : DataFrame where new features will be added\n",
    "    feature_name : Name of the feature of date type which needs to be decomposed.\n",
    "    '''\n",
    "    target_df.loc[:, 'year'] = source_df.loc[:, feature_name].dt.year.astype('uint16')\n",
    "    target_df.loc[:, 'month'] = source_df.loc[:, feature_name].dt.month.astype('uint8')\n",
    "    target_df.loc[:, 'quarter'] = source_df.loc[:, feature_name].dt.quarter.astype('uint8')\n",
    "    target_df.loc[:, 'weekofyear'] = source_df.loc[:, feature_name].dt.isocalendar().week.astype('uint8')\n",
    "    \n",
    "    target_df.loc[:, 'hour'] = source_df.loc[:, feature_name].dt.hour.astype('uint8')\n",
    "    \n",
    "    target_df.loc[:, 'day'] = source_df.loc[:, feature_name].dt.day.astype('uint8')\n",
    "    target_df.loc[:, 'dayofweek'] = source_df.loc[:, feature_name].dt.dayofweek.astype('uint8')\n",
    "    target_df.loc[:, 'dayofyear'] = source_df.loc[:, feature_name].dt.dayofyear.astype('uint8')\n",
    "    target_df.loc[:, 'is_month_start'] = source_df.loc[:, feature_name].dt.is_month_start\n",
    "    target_df.loc[:, 'is_month_end'] = source_df.loc[:, feature_name].dt.is_month_end\n",
    "    target_df.loc[:, 'is_quarter_start']= source_df.loc[:, feature_name].dt.is_quarter_start\n",
    "    target_df.loc[:, 'is_quarter_end'] = source_df.loc[:, feature_name].dt.is_quarter_end\n",
    "    target_df.loc[:, 'is_year_start'] = source_df.loc[:, feature_name].dt.is_year_start\n",
    "    target_df.loc[:, 'is_year_end'] = source_df.loc[:, feature_name].dt.is_year_end\n",
    "    \n",
    "    # This is of type object\n",
    "    target_df.loc[:, 'month_year'] = source_df.loc[:, feature_name].dt.to_period('M')\n",
    "    \n",
    "    return target_df\n",
    "\n",
    "\n",
    "def plot_boxh_groupby(df, feature_name, by):\n",
    "    \"\"\"\n",
    "    Box plot with groupby\n",
    "    \n",
    "    df: DataFrame\n",
    "    feature_name: Name of the feature to be plotted\n",
    "    by: Name of the feature based on which groups are created\n",
    "    \"\"\"\n",
    "    df.boxplot(column=feature_name, by=by, vert=False, \n",
    "                              figsize=(10, 6))\n",
    "    plt.title(f'Distribution of {feature_name} by {by}')\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "def plot_hist(df, feature_name, kind='hist', bins=100, log=True):\n",
    "    \"\"\"\n",
    "    Plot histogram.\n",
    "    \n",
    "    df: DataFrame\n",
    "    feature_name: Name of the feature to be plotted.\n",
    "    \"\"\"\n",
    "    if log:\n",
    "        df[feature_name].apply(np.log1p).plot(kind='hist', \n",
    "                                              bins=bins, \n",
    "                                              figsize=(15, 5), \n",
    "                                              title=f'Distribution of log1p[{feature_name}]')\n",
    "    else:\n",
    "        df[feature_name].plot(kind='hist', \n",
    "                              bins=bins, \n",
    "                              figsize=(15, 5), \n",
    "                              title=f'Distribution of {feature_name}')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "def plot_ts(series, figsize=(20, 6), title=None, xlabel=\"\", ylabel=\"\"):\n",
    "    \"\"\"\n",
    "    Plot Time Series data. The series object should have date or time as index.\n",
    "    \n",
    "    series: Series object to be plotted.\n",
    "    \"\"\"\n",
    "    series.plot(figsize=figsize, title=title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_barh(df, feature_name, normalize=True, \n",
    "              kind='barh', figsize=(15,5), sort_index=False, title=None):\n",
    "    \"\"\"\n",
    "    Plot barh for a particular feature\n",
    "    \n",
    "    kind : Type of the plot\n",
    "    \n",
    "    \"\"\"\n",
    "    if sort_index==True:\n",
    "        df[feature_name].value_counts(\n",
    "                normalize=normalize, dropna=False).sort_index().plot(\n",
    "                kind=kind, figsize=figsize, grid=True,\n",
    "                title=title)\n",
    "    else:   \n",
    "        df[feature_name].value_counts(\n",
    "                normalize=normalize, dropna=False).sort_values().plot(\n",
    "                kind=kind, figsize=figsize, grid=True,\n",
    "                title=title)\n",
    "    \n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_boxh(df, feature_name, kind='box', log=True):\n",
    "    \"\"\"\n",
    "    Box plot\n",
    "    \"\"\"\n",
    "    if log:\n",
    "        df[feature_name].apply(np.log1p).plot(kind='box', vert=False, \n",
    "                                                  figsize=(10, 6), \n",
    "                                                  title=f'Distribution of log1p[{feature_name}]')\n",
    "    else:\n",
    "        df[feature_name].plot(kind='box', vert=False, \n",
    "                              figsize=(10, 6), \n",
    "                              title=f'Distribution of {feature_name}')\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "def plot_scatter(df, feature_x, feature_y, figsize=(10,10), \n",
    "                 title=None, xlabel=None, ylabel=None):\n",
    "    \"\"\"\n",
    "    Plot scatter     \n",
    "    \"\"\"\n",
    "    df.plot.scatter(feature_x, feature_y, \n",
    "                    figsize=(8, 6), title=title, \n",
    "                    legend=None)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Telemetry Time Series Data (PdM_telemetry.csv)\n",
    "\n",
    "We are displaying the first 5 records in the dataset. A summary of the whole dataset is also provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of telemetry records: 876100\n",
      "             datetime  machineID        volt      rotate    pressure  \\\n",
      "0 2015-01-01 06:00:00          1  176.217853  418.504078  113.077935   \n",
      "1 2015-01-01 07:00:00          1  162.879223  402.747490   95.460525   \n",
      "2 2015-01-01 08:00:00          1  170.989902  527.349825   75.237905   \n",
      "3 2015-01-01 09:00:00          1  162.462833  346.149335  109.248561   \n",
      "4 2015-01-01 10:00:00          1  157.610021  435.376873  111.886648   \n",
      "\n",
      "   vibration  \n",
      "0  45.087686  \n",
      "1  43.413973  \n",
      "2  34.178847  \n",
      "3  41.122144  \n",
      "4  25.990511  \n",
      "\n",
      "Summary of the dataset:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>machineID</th>\n",
       "      <th>volt</th>\n",
       "      <th>rotate</th>\n",
       "      <th>pressure</th>\n",
       "      <th>vibration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>876100.000000</td>\n",
       "      <td>876100.000000</td>\n",
       "      <td>876100.000000</td>\n",
       "      <td>876100.000000</td>\n",
       "      <td>876100.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>50.500000</td>\n",
       "      <td>170.777736</td>\n",
       "      <td>446.605119</td>\n",
       "      <td>100.858668</td>\n",
       "      <td>40.385007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>28.866087</td>\n",
       "      <td>15.509114</td>\n",
       "      <td>52.673886</td>\n",
       "      <td>11.048679</td>\n",
       "      <td>5.370361</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>97.333604</td>\n",
       "      <td>138.432075</td>\n",
       "      <td>51.237106</td>\n",
       "      <td>14.877054</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>25.750000</td>\n",
       "      <td>160.304927</td>\n",
       "      <td>412.305714</td>\n",
       "      <td>93.498181</td>\n",
       "      <td>36.777299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>50.500000</td>\n",
       "      <td>170.607338</td>\n",
       "      <td>447.558150</td>\n",
       "      <td>100.425559</td>\n",
       "      <td>40.237247</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>75.250000</td>\n",
       "      <td>181.004493</td>\n",
       "      <td>482.176600</td>\n",
       "      <td>107.555231</td>\n",
       "      <td>43.784938</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>100.000000</td>\n",
       "      <td>255.124717</td>\n",
       "      <td>695.020984</td>\n",
       "      <td>185.951998</td>\n",
       "      <td>76.791072</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           machineID           volt         rotate       pressure  \\\n",
       "count  876100.000000  876100.000000  876100.000000  876100.000000   \n",
       "mean       50.500000     170.777736     446.605119     100.858668   \n",
       "std        28.866087      15.509114      52.673886      11.048679   \n",
       "min         1.000000      97.333604     138.432075      51.237106   \n",
       "25%        25.750000     160.304927     412.305714      93.498181   \n",
       "50%        50.500000     170.607338     447.558150     100.425559   \n",
       "75%        75.250000     181.004493     482.176600     107.555231   \n",
       "max       100.000000     255.124717     695.020984     185.951998   \n",
       "\n",
       "           vibration  \n",
       "count  876100.000000  \n",
       "mean       40.385007  \n",
       "std         5.370361  \n",
       "min        14.877054  \n",
       "25%        36.777299  \n",
       "50%        40.237247  \n",
       "75%        43.784938  \n",
       "max        76.791072  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Format datetime field which comes in as string\n",
    "\n",
    "telemetry['datetime'] = pd.to_datetime(telemetry['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "\n",
    "print(\"Total number of telemetry records: %d\" % len(telemetry.index))\n",
    "print(telemetry.head())\n",
    "print()#print blank space\n",
    "print(\"Summary of the dataset:\")\n",
    "telemetry.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>How many Machines are there?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "telemetry.machineID.nunique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>What is the duration of the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count                           876100\n",
       "mean     2015-07-02 17:59:59.999988992\n",
       "min                2015-01-01 06:00:00\n",
       "25%                2015-04-02 12:00:00\n",
       "50%                2015-07-02 18:00:00\n",
       "75%                2015-10-02 00:00:00\n",
       "max                2016-01-01 06:00:00\n",
       "Name: datetime, dtype: object"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "telemetry.datetime.describe(datetime_is_numeric=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Telemetry data is distributed between 1st Jan 2015 to 1st Jan 2016. It seems that the data is having hourly frequency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Are there any missinge days in the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex([], dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_missing_dates(telemetry.datetime, \n",
    "                  start_date=\"2015-01-01 06:00:00\", \n",
    "                  end_date=\"2016-01-01 06:00:00\", \n",
    "                  freq='H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no missing data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Are there any duplicates?</b> <br>\n",
    "One Machine should not have multiple rows with the same time stamp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_duplicate(telemetry, ['datetime', 'machineID'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are no duplicates in the telemetry data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Are there any Null values in the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime     0.0\n",
       "machineID    0.0\n",
       "volt         0.0\n",
       "rotate       0.0\n",
       "pressure     0.0\n",
       "vibration    0.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_null(telemetry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are no missing values in the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Let's plot Vibration of Machine 55 for 2015"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's plot Vibration of Machine 55 for 2015\n",
    "df_vib_machine_1 = telemetry[\n",
    "    telemetry.machineID == 55][[\"datetime\", \"vibration\"]].set_index(\"datetime\")\n",
    "plot_ts(df_vib_machine_1, title=\"Vibration of Machine 55\", xlabel=\"Time\", ylabel=\"Vibration\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example, below is a plot of voltage values for machine ID=1 for the first half of 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "plot_df = telemetry.loc[(telemetry['machineID'] == 1) &\n",
    "                        (telemetry['datetime'] > pd.to_datetime('2015-01-01')) &\n",
    "                        (telemetry['datetime'] < pd.to_datetime('2015-02-01')), ['datetime', 'volt']]\n",
    "\n",
    "sns.set_style(\"darkgrid\")\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.plot(plot_df['datetime'], plot_df['volt'])\n",
    "plt.ylabel('voltage',fontsize=14)\n",
    "\n",
    "# make x-axis ticks legible\n",
    "adf = plt.gca().get_xaxis().get_major_formatter()\n",
    "adf.scaled[1.0] = '%m-%d'\n",
    "plt.xlabel('Date',fontsize=14)\n",
    "plt.title(\"Sample of distribution plot of voltage\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Let's plot the distribution of Voltage across Machines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"darkgrid\")\n",
    "plot_hist(telemetry, feature_name=\"volt\", log=False, bins=222)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The distribution is a perfect normal curve."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Let's verify it by plotting histogram of other parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for name in ['rotate', 'pressure', 'vibration']:\n",
    "    plot_hist(telemetry, feature_name=name, log=False, bins=222)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vibration, rotation and pressure are also normally distributed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Observations on Telemetry Data</b>\n",
    "- The data distributed between 1st Jan 2015 to 1st Jan 2016.\n",
    "- Each row represents the state of a machine on a particular hour. Voltage, vibration, pressure &       rotation of a machine have been averaged hourly.\n",
    "- There are 100 unique Machines.\n",
    "- There are no duplicates or missing values in the dataset.\n",
    "- The four parameters voltage, vibration, pressure & rotation are normally distributed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Errors Dataset (PdM_errors.csv)\n",
    "\n",
    "This data includes the errors encountered by the machines while in operating condition. Since, these errors don't shut down the machines, these are not considered as failures. The error date and times are rounded to the closest hour since the telemetry data is collected at an hourly rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of error records: 3919\n",
      "             datetime  machineID errorID\n",
      "0 2015-01-03 07:00:00          1  error1\n",
      "1 2015-01-03 20:00:00          1  error3\n",
      "2 2015-01-04 06:00:00          1  error5\n",
      "3 2015-01-10 15:00:00          1  error4\n",
      "4 2015-01-22 10:00:00          1  error4\n"
     ]
    }
   ],
   "source": [
    "# Format datetime field which comes in as string\n",
    "errors['datetime'] = pd.to_datetime(errors['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "errors['errorID'] = errors['errorID'].astype('category')\n",
    "\n",
    "print(\"Total number of error records: %d\" % len(errors.index))\n",
    "print(errors.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Are there any duplicates?</b><br>\n",
    "One Machine should not have multiple errors with the same time stamp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_duplicate(errors, ['datetime', 'machineID', 'errorID'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are no duplicates in the error data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plotting the histrogram of errors.\n",
    "sns.set_style(\"darkgrid\")\n",
    "plt.figure(figsize=(8, 4))\n",
    "errors['errorID'].value_counts().plot(kind='bar', fontsize=14)\n",
    "plt.title(\"Histrogram of errors\", fontsize=16)\n",
    "plt.ylabel('Count', fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type 1 & 2 errors are most frequent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Maintenance (PdM_maint.csv)\n",
    "\n",
    "If a component of a machine is replaced, that is captured as a record in this table. Components are replaced under two situations:\n",
    "\n",
    "- During the regular scheduled visit, the technician replaced it (Proactive Maintenance)\n",
    "- A component breaks down and then the technician does an unscheduled maintenance to replace the component (Reactive Maintenance). This is considered as a failure and corresponding data is captured under Failures. Maintenance data has both 2014 and 2015 records. This data is rounded to the closest hour since the telemetry data is collected at an hourly rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of maintenance records: 3286\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>comp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2014-06-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2014-07-16 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2014-07-31 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2014-12-13 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015-01-05 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID   comp\n",
       "0 2014-06-01 06:00:00          1  comp2\n",
       "1 2014-07-16 06:00:00          1  comp4\n",
       "2 2014-07-31 06:00:00          1  comp3\n",
       "3 2014-12-13 06:00:00          1  comp1\n",
       "4 2015-01-05 06:00:00          1  comp4"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Format datetime field which comes in as string\n",
    "maint['datetime'] = pd.to_datetime(maint['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "maint['comp'] = maint['comp'].astype('category')\n",
    "\n",
    "print(\"Total number of maintenance records: %d\" % len(maint.index))\n",
    "maint.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"darkgrid\")\n",
    "plt.figure(figsize=(8, 4))\n",
    "maint['comp'].value_counts().plot(kind='bar',fontsize=14)\n",
    "plt.ylabel('Count', fontsize=14)\n",
    "plt.title(\"Histrogram of replaced components\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Four types components are replaced almost in the same numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metadata of Machines (PdM_Machines.csv)\n",
    "\n",
    "This data set includes some information about the machines: model type and age (years in service)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of machines: 100\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>machineID</th>\n",
       "      <th>model</th>\n",
       "      <th>age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>model3</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>model4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>model3</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>model3</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>model3</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   machineID   model  age\n",
       "0          1  model3   18\n",
       "1          2  model4    7\n",
       "2          3  model3    8\n",
       "3          4  model3    7\n",
       "4          5  model3    2"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "machines['model'] = machines['model'].astype('category')\n",
    "\n",
    "print(\"Total number of machines: %d\" % len(machines.index))\n",
    "machines.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Create a Data Frame with number of errors, maintenance records and failure records across machines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>machineID</th>\n",
       "      <th>model</th>\n",
       "      <th>age</th>\n",
       "      <th>num_errors</th>\n",
       "      <th>num_maint</th>\n",
       "      <th>num_failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>model3</td>\n",
       "      <td>18</td>\n",
       "      <td>35</td>\n",
       "      <td>37</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>model4</td>\n",
       "      <td>7</td>\n",
       "      <td>28</td>\n",
       "      <td>32</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>model3</td>\n",
       "      <td>8</td>\n",
       "      <td>39</td>\n",
       "      <td>37</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>model3</td>\n",
       "      <td>7</td>\n",
       "      <td>31</td>\n",
       "      <td>33</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>model3</td>\n",
       "      <td>2</td>\n",
       "      <td>38</td>\n",
       "      <td>35</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   machineID   model  age  num_errors  num_maint  num_failure\n",
       "0          1  model3   18          35         37          7.0\n",
       "1          2  model4    7          28         32          4.0\n",
       "2          3  model3    8          39         37          5.0\n",
       "3          4  model3    7          31         33          6.0\n",
       "4          5  model3    2          38         35          7.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a DF with number of errors, maintenance records and failure records across machines\n",
    "\n",
    "# Create a DF consisting of number of erros across Machines\n",
    "erros_across_machine = errors.groupby(\"machineID\").size()\n",
    "erros_across_machine = pd.DataFrame(erros_across_machine, columns=[\"num_errors\"]).reset_index()\n",
    "\n",
    "machines_errors_df = pd.merge(machines, erros_across_machine, how='left', on=\"machineID\")\n",
    "\n",
    "# Create a DF consisting of number of maintenance records across Machines\n",
    "maint_across_machine = maint.groupby(\"machineID\").size()\n",
    "maint_across_machine = pd.DataFrame(maint_across_machine, columns=[\"num_maint\"]).reset_index()\n",
    "\n",
    "machines_errors_df = pd.merge(machines_errors_df, maint_across_machine, how='left', on=\"machineID\")\n",
    "\n",
    "# Create a DF consisting of number of failure records across Machines\n",
    "failure_across_machine = failures.groupby(\"machineID\").size()\n",
    "failure_across_machine = pd.DataFrame(failure_across_machine, columns=[\"num_failure\"]).reset_index()\n",
    "\n",
    "machines_errors_df = pd.merge(machines_errors_df, failure_across_machine, how='left', on=\"machineID\")\n",
    "\n",
    "machines_errors_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compute correlation values in machines_errors_df."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>machineID</th>\n",
       "      <th>age</th>\n",
       "      <th>num_errors</th>\n",
       "      <th>num_maint</th>\n",
       "      <th>num_failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>machineID</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.100196</td>\n",
       "      <td>0.107982</td>\n",
       "      <td>-0.077903</td>\n",
       "      <td>0.096496</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>age</th>\n",
       "      <td>0.100196</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.106931</td>\n",
       "      <td>0.075445</td>\n",
       "      <td>0.476459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>num_errors</th>\n",
       "      <td>0.107982</td>\n",
       "      <td>0.106931</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.026558</td>\n",
       "      <td>0.483735</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>num_maint</th>\n",
       "      <td>-0.077903</td>\n",
       "      <td>0.075445</td>\n",
       "      <td>-0.026558</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.030258</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>num_failure</th>\n",
       "      <td>0.096496</td>\n",
       "      <td>0.476459</td>\n",
       "      <td>0.483735</td>\n",
       "      <td>-0.030258</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             machineID       age  num_errors  num_maint  num_failure\n",
       "machineID     1.000000  0.100196    0.107982  -0.077903     0.096496\n",
       "age           0.100196  1.000000    0.106931   0.075445     0.476459\n",
       "num_errors    0.107982  0.106931    1.000000  -0.026558     0.483735\n",
       "num_maint    -0.077903  0.075445   -0.026558   1.000000    -0.030258\n",
       "num_failure   0.096496  0.476459    0.483735  -0.030258     1.000000"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "machines_errors_df.corr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above table, it is observed that attribute 'age' and 'number errors' have correlation with number of failure.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Failures (PdM_failures.csv)\n",
    "\n",
    "These are the records of component replacements due to failures. Each record has a date and time, machine ID, and failed component type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of failures: 761\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-05 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-03-06 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2015-04-20 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2015-06-19 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015-09-02 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID failure\n",
       "0 2015-01-05 06:00:00          1   comp4\n",
       "1 2015-03-06 06:00:00          1   comp1\n",
       "2 2015-04-20 06:00:00          1   comp2\n",
       "3 2015-06-19 06:00:00          1   comp4\n",
       "4 2015-09-02 06:00:00          1   comp4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Format datetime field which comes in as string.\n",
    "\n",
    "failures['datetime'] = pd.to_datetime(failures['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "failures['failure'] = failures['failure'].astype('category')\n",
    "\n",
    "print(\"Total number of failures: %d\" % len(failures.index))\n",
    "failures.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is the histogram of the failures due to each component. We see that the most failures happen due to component 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"darkgrid\")\n",
    "plt.figure(figsize=(8, 4))\n",
    "failures['failure'].value_counts().plot(kind='bar', fontsize=14)\n",
    "plt.ylabel('Count', fontsize=14)\n",
    "plt.title(\"Histogram of component failure\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# First Cut Approach:\n",
    "\n",
    "<b>Objective of this step to predict the failure of machines' components (comp1, comp2 etc.) based on available data without performing feature engineering and hyper-parameter tuning of model. <br>\n",
    "   Steps to be followed:</b>\n",
    "1. Load all the data sets\n",
    "2. Perform one hot encoding for categorical attributes\n",
    "3. Merger all the data sets after step no-2.\n",
    "4. Split the data sets into train, cross validation and test set.\n",
    "5. Apply Xgboost classifier and random forest classifier on train data set.\n",
    "6. As the dataset is highly imbalance, so F1 score, Precision, Recall and Confusion matrix will be computed to validate the performance of models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading all the datasets using Pandas library\n",
    "import pandas as pd\n",
    "\n",
    "telemetry = pd.read_csv('PdM_telemetry.csv')\n",
    "errors = pd.read_csv('PdM_errors.csv')\n",
    "maint = pd.read_csv('PdM_maint.csv')\n",
    "failures = pd.read_csv('PdM_failures.csv')\n",
    "machines = pd.read_csv('PdM_machines.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Formating datetime field.\n",
    "telemetry['datetime'] = pd.to_datetime(telemetry['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "\n",
    "errors['datetime'] = pd.to_datetime(errors['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "errors['errorID'] = errors['errorID'].astype('category')\n",
    "\n",
    "maint['datetime'] = pd.to_datetime(maint['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "maint['comp'] = maint['comp'].astype('category')\n",
    "\n",
    "machines['model'] = machines['model'].astype('category')\n",
    "\n",
    "failures['datetime'] = pd.to_datetime(failures['datetime'], format=\"%Y-%m-%d %H:%M:%S\")\n",
    "failures['failure'] = failures['failure'].astype('category')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>volt</th>\n",
       "      <th>rotate</th>\n",
       "      <th>pressure</th>\n",
       "      <th>vibration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>176.217853</td>\n",
       "      <td>418.504078</td>\n",
       "      <td>113.077935</td>\n",
       "      <td>45.087686</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>162.879223</td>\n",
       "      <td>402.747490</td>\n",
       "      <td>95.460525</td>\n",
       "      <td>43.413973</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID        volt      rotate    pressure  \\\n",
       "0 2015-01-01 06:00:00          1  176.217853  418.504078  113.077935   \n",
       "1 2015-01-01 07:00:00          1  162.879223  402.747490   95.460525   \n",
       "\n",
       "   vibration  \n",
       "0  45.087686  \n",
       "1  43.413973  "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "telemetry.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>errorID</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-03 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>error1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-03 20:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>error3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID errorID\n",
       "0 2015-01-03 07:00:00          1  error1\n",
       "1 2015-01-03 20:00:00          1  error3"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "errors.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>errorID_error1</th>\n",
       "      <th>errorID_error2</th>\n",
       "      <th>errorID_error3</th>\n",
       "      <th>errorID_error4</th>\n",
       "      <th>errorID_error5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-03 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-03 20:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID  errorID_error1  errorID_error2  \\\n",
       "0 2015-01-03 07:00:00          1               1               0   \n",
       "1 2015-01-03 20:00:00          1               0               0   \n",
       "\n",
       "   errorID_error3  errorID_error4  errorID_error5  \n",
       "0               0               0               0  \n",
       "1               1               0               0  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "errors=pd.get_dummies(errors)\n",
    "errors.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>comp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2014-06-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2014-07-16 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID   comp\n",
       "0 2014-06-01 06:00:00          1  comp2\n",
       "1 2014-07-16 06:00:00          1  comp4"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maint.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>comp_comp1</th>\n",
       "      <th>comp_comp2</th>\n",
       "      <th>comp_comp3</th>\n",
       "      <th>comp_comp4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2014-06-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2014-07-16 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID  comp_comp1  comp_comp2  comp_comp3  \\\n",
       "0 2014-06-01 06:00:00          1           0           1           0   \n",
       "1 2014-07-16 06:00:00          1           0           0           0   \n",
       "\n",
       "   comp_comp4  \n",
       "0           0  \n",
       "1           1  "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maint=pd.get_dummies(maint)\n",
    "maint.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>machineID</th>\n",
       "      <th>model</th>\n",
       "      <th>age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>model3</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>model4</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   machineID   model  age\n",
       "0          1  model3   18\n",
       "1          2  model4    7"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "machines.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>machineID</th>\n",
       "      <th>age</th>\n",
       "      <th>model_model1</th>\n",
       "      <th>model_model2</th>\n",
       "      <th>model_model3</th>\n",
       "      <th>model_model4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   machineID  age  model_model1  model_model2  model_model3  model_model4\n",
       "0          1   18             0             0             1             0\n",
       "1          2    7             0             0             0             1"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "machines=pd.get_dummies(machines)\n",
    "machines.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-05 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-03-06 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>comp1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID failure\n",
       "0 2015-01-05 06:00:00          1   comp4\n",
       "1 2015-03-06 06:00:00          1   comp1"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "failures.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>errorID_error1</th>\n",
       "      <th>errorID_error2</th>\n",
       "      <th>errorID_error3</th>\n",
       "      <th>errorID_error4</th>\n",
       "      <th>errorID_error5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID  errorID_error1  errorID_error2  \\\n",
       "0 2015-01-01 06:00:00          1             0.0             0.0   \n",
       "1 2015-01-01 07:00:00          1             0.0             0.0   \n",
       "\n",
       "   errorID_error3  errorID_error4  errorID_error5  \n",
       "0             0.0             0.0             0.0  \n",
       "1             0.0             0.0             0.0  "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_error_merge = telemetry[['datetime', 'machineID']].merge(errors, on=['machineID', 'datetime'], \n",
    "                                                         how='outer').fillna(0)\n",
    "\n",
    "tel_error_merge.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(876100, 6)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "telemetry.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(876403, 7)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_error_merge.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>comp_comp1</th>\n",
       "      <th>comp_comp2</th>\n",
       "      <th>comp_comp3</th>\n",
       "      <th>comp_comp4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID  comp_comp1  comp_comp2  comp_comp3  \\\n",
       "0 2015-01-01 06:00:00          1         0.0         0.0         0.0   \n",
       "1 2015-01-01 07:00:00          1         0.0         0.0         0.0   \n",
       "\n",
       "   comp_comp4  \n",
       "0         0.0  \n",
       "1         0.0  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_maint_merge = telemetry[['datetime', 'machineID']].merge(maint, on=['machineID', 'datetime'], \n",
    "                                                         how='outer').fillna(0)\n",
    "\n",
    "tel_maint_merge.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(877223, 6)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_maint_merge.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>volt</th>\n",
       "      <th>rotate</th>\n",
       "      <th>pressure</th>\n",
       "      <th>vibration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>176.217853</td>\n",
       "      <td>418.504078</td>\n",
       "      <td>113.077935</td>\n",
       "      <td>45.087686</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>162.879223</td>\n",
       "      <td>402.747490</td>\n",
       "      <td>95.460525</td>\n",
       "      <td>43.413973</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID        volt      rotate    pressure  \\\n",
       "0 2015-01-01 06:00:00          1  176.217853  418.504078  113.077935   \n",
       "1 2015-01-01 07:00:00          1  162.879223  402.747490   95.460525   \n",
       "\n",
       "   vibration  \n",
       "0  45.087686  \n",
       "1  43.413973  "
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "telemetry.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "tel_maint_mac_merge = tel_maint_merge.merge(machines, on=['machineID'], how='left').fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>comp_comp1</th>\n",
       "      <th>comp_comp2</th>\n",
       "      <th>comp_comp3</th>\n",
       "      <th>comp_comp4</th>\n",
       "      <th>age</th>\n",
       "      <th>model_model1</th>\n",
       "      <th>model_model2</th>\n",
       "      <th>model_model3</th>\n",
       "      <th>model_model4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID  comp_comp1  comp_comp2  comp_comp3  \\\n",
       "0 2015-01-01 06:00:00          1         0.0         0.0         0.0   \n",
       "1 2015-01-01 07:00:00          1         0.0         0.0         0.0   \n",
       "\n",
       "   comp_comp4  age  model_model1  model_model2  model_model3  model_model4  \n",
       "0         0.0   18             0             0             1             0  \n",
       "1         0.0   18             0             0             1             0  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_maint_mac_merge.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(877223, 11)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_maint_mac_merge.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID failure\n",
       "0 2015-01-01 06:00:00          1     NaN\n",
       "1 2015-01-01 07:00:00          1     NaN"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_fail_merge = telemetry[['datetime', 'machineID']].merge(failures, on=['machineID', 'datetime'], \n",
    "                                                         how='left')\n",
    "\n",
    "tel_fail_merge.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(876142, 3)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tel_fail_merge.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_df = telemetry.merge(tel_error_merge, on=['datetime', 'machineID'], how='left')\n",
    "final_df = final_df.merge(tel_maint_mac_merge, on=['datetime', 'machineID'], how='left')\n",
    "final_df = final_df.merge(tel_fail_merge, on=['datetime', 'machineID'], how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>volt</th>\n",
       "      <th>rotate</th>\n",
       "      <th>pressure</th>\n",
       "      <th>vibration</th>\n",
       "      <th>errorID_error1</th>\n",
       "      <th>errorID_error2</th>\n",
       "      <th>errorID_error3</th>\n",
       "      <th>errorID_error4</th>\n",
       "      <th>...</th>\n",
       "      <th>comp_comp1</th>\n",
       "      <th>comp_comp2</th>\n",
       "      <th>comp_comp3</th>\n",
       "      <th>comp_comp4</th>\n",
       "      <th>age</th>\n",
       "      <th>model_model1</th>\n",
       "      <th>model_model2</th>\n",
       "      <th>model_model3</th>\n",
       "      <th>model_model4</th>\n",
       "      <th>failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>176.217853</td>\n",
       "      <td>418.504078</td>\n",
       "      <td>113.077935</td>\n",
       "      <td>45.087686</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>162.879223</td>\n",
       "      <td>402.747490</td>\n",
       "      <td>95.460525</td>\n",
       "      <td>43.413973</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 21 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID        volt      rotate    pressure  \\\n",
       "0 2015-01-01 06:00:00          1  176.217853  418.504078  113.077935   \n",
       "1 2015-01-01 07:00:00          1  162.879223  402.747490   95.460525   \n",
       "\n",
       "   vibration  errorID_error1  errorID_error2  errorID_error3  errorID_error4  \\\n",
       "0  45.087686             0.0             0.0             0.0             0.0   \n",
       "1  43.413973             0.0             0.0             0.0             0.0   \n",
       "\n",
       "   ...  comp_comp1  comp_comp2  comp_comp3  comp_comp4  age  model_model1  \\\n",
       "0  ...         0.0         0.0         0.0         0.0   18             0   \n",
       "1  ...         0.0         0.0         0.0         0.0   18             0   \n",
       "\n",
       "   model_model2  model_model3  model_model4  failure  \n",
       "0             0             1             0      NaN  \n",
       "1             0             1             0      NaN  \n",
       "\n",
       "[2 rows x 21 columns]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(877209, 21)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>volt</th>\n",
       "      <th>rotate</th>\n",
       "      <th>pressure</th>\n",
       "      <th>vibration</th>\n",
       "      <th>errorID_error1</th>\n",
       "      <th>errorID_error2</th>\n",
       "      <th>errorID_error3</th>\n",
       "      <th>errorID_error4</th>\n",
       "      <th>...</th>\n",
       "      <th>comp_comp1</th>\n",
       "      <th>comp_comp2</th>\n",
       "      <th>comp_comp3</th>\n",
       "      <th>comp_comp4</th>\n",
       "      <th>age</th>\n",
       "      <th>model_model1</th>\n",
       "      <th>model_model2</th>\n",
       "      <th>model_model3</th>\n",
       "      <th>model_model4</th>\n",
       "      <th>failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>877207</th>\n",
       "      <td>2016-01-01 05:00:00</td>\n",
       "      <td>100</td>\n",
       "      <td>165.475310</td>\n",
       "      <td>413.77167</td>\n",
       "      <td>104.081073</td>\n",
       "      <td>44.835259</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>877208</th>\n",
       "      <td>2016-01-01 06:00:00</td>\n",
       "      <td>100</td>\n",
       "      <td>171.336037</td>\n",
       "      <td>496.09687</td>\n",
       "      <td>79.095538</td>\n",
       "      <td>37.845245</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 21 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                  datetime  machineID        volt     rotate    pressure  \\\n",
       "877207 2016-01-01 05:00:00        100  165.475310  413.77167  104.081073   \n",
       "877208 2016-01-01 06:00:00        100  171.336037  496.09687   79.095538   \n",
       "\n",
       "        vibration  errorID_error1  errorID_error2  errorID_error3  \\\n",
       "877207  44.835259             0.0             0.0             0.0   \n",
       "877208  37.845245             0.0             0.0             0.0   \n",
       "\n",
       "        errorID_error4  ...  comp_comp1  comp_comp2  comp_comp3  comp_comp4  \\\n",
       "877207             0.0  ...         0.0         0.0         0.0         0.0   \n",
       "877208             0.0  ...         0.0         0.0         0.0         0.0   \n",
       "\n",
       "        age  model_model1  model_model2  model_model3  model_model4  failure  \n",
       "877207    5             0             0             0             1      NaN  \n",
       "877208    5             0             0             0             1      NaN  \n",
       "\n",
       "[2 rows x 21 columns]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_df.tail(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_df['failure'] = final_df['failure'].astype('str')\n",
    "final_df.replace({'nan': \"none\"}, inplace= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>datetime</th>\n",
       "      <th>machineID</th>\n",
       "      <th>volt</th>\n",
       "      <th>rotate</th>\n",
       "      <th>pressure</th>\n",
       "      <th>vibration</th>\n",
       "      <th>errorID_error1</th>\n",
       "      <th>errorID_error2</th>\n",
       "      <th>errorID_error3</th>\n",
       "      <th>errorID_error4</th>\n",
       "      <th>...</th>\n",
       "      <th>comp_comp1</th>\n",
       "      <th>comp_comp2</th>\n",
       "      <th>comp_comp3</th>\n",
       "      <th>comp_comp4</th>\n",
       "      <th>age</th>\n",
       "      <th>model_model1</th>\n",
       "      <th>model_model2</th>\n",
       "      <th>model_model3</th>\n",
       "      <th>model_model4</th>\n",
       "      <th>failure</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-01-01 06:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>176.217853</td>\n",
       "      <td>418.504078</td>\n",
       "      <td>113.077935</td>\n",
       "      <td>45.087686</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>none</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-01-01 07:00:00</td>\n",
       "      <td>1</td>\n",
       "      <td>162.879223</td>\n",
       "      <td>402.747490</td>\n",
       "      <td>95.460525</td>\n",
       "      <td>43.413973</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>none</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 21 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             datetime  machineID        volt      rotate    pressure  \\\n",
       "0 2015-01-01 06:00:00          1  176.217853  418.504078  113.077935   \n",
       "1 2015-01-01 07:00:00          1  162.879223  402.747490   95.460525   \n",
       "\n",
       "   vibration  errorID_error1  errorID_error2  errorID_error3  errorID_error4  \\\n",
       "0  45.087686             0.0             0.0             0.0             0.0   \n",
       "1  43.413973             0.0             0.0             0.0             0.0   \n",
       "\n",
       "   ...  comp_comp1  comp_comp2  comp_comp3  comp_comp4  age  model_model1  \\\n",
       "0  ...         0.0         0.0         0.0         0.0   18             0   \n",
       "1  ...         0.0         0.0         0.0         0.0   18             0   \n",
       "\n",
       "   model_model2  model_model3  model_model4  failure  \n",
       "0             0             1             0     none  \n",
       "1             0             1             0     none  \n",
       "\n",
       "[2 rows x 21 columns]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #Let's save 'final_df' in csv format\n",
    "\n",
    "# final_df.to_csv('final_df_first_cut.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = final_df.drop(['datetime', 'machineID', 'failure'], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>volt</th>\n",
       "      <th>rotate</th>\n",
       "      <th>pressure</th>\n",
       "      <th>vibration</th>\n",
       "      <th>errorID_error1</th>\n",
       "      <th>errorID_error2</th>\n",
       "      <th>errorID_error3</th>\n",
       "      <th>errorID_error4</th>\n",
       "      <th>errorID_error5</th>\n",
       "      <th>comp_comp1</th>\n",
       "      <th>comp_comp2</th>\n",
       "      <th>comp_comp3</th>\n",
       "      <th>comp_comp4</th>\n",
       "      <th>age</th>\n",
       "      <th>model_model1</th>\n",
       "      <th>model_model2</th>\n",
       "      <th>model_model3</th>\n",
       "      <th>model_model4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>176.217853</td>\n",
       "      <td>418.504078</td>\n",
       "      <td>113.077935</td>\n",
       "      <td>45.087686</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>162.879223</td>\n",
       "      <td>402.747490</td>\n",
       "      <td>95.460525</td>\n",
       "      <td>43.413973</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>18</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         volt      rotate    pressure  vibration  errorID_error1  \\\n",
       "0  176.217853  418.504078  113.077935  45.087686             0.0   \n",
       "1  162.879223  402.747490   95.460525  43.413973             0.0   \n",
       "\n",
       "   errorID_error2  errorID_error3  errorID_error4  errorID_error5  comp_comp1  \\\n",
       "0             0.0             0.0             0.0             0.0         0.0   \n",
       "1             0.0             0.0             0.0             0.0         0.0   \n",
       "\n",
       "   comp_comp2  comp_comp3  comp_comp4  age  model_model1  model_model2  \\\n",
       "0         0.0         0.0         0.0   18             0             0   \n",
       "1         0.0         0.0         0.0   18             0             0   \n",
       "\n",
       "   model_model3  model_model4  \n",
       "0             1             0  \n",
       "1             1             0  "
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([162.8792229 , 402.74748957,  95.46052538,  43.41397268,\n",
       "         0.        ,   0.        ,   0.        ,   0.        ,\n",
       "         0.        ,   0.        ,   0.        ,   0.        ,\n",
       "         0.        ,  18.        ,   0.        ,   0.        ,\n",
       "         1.        ,   0.        ])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_final_train = X.values\n",
    "X_final_train[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    none\n",
       "1    none\n",
       "Name: failure, dtype: object"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_final=final_df['failure']\n",
    "y_final.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'none'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_final_train = y_final.values\n",
    "y_final_train[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X_final_train, y_final_train,test_size=0.20, shuffle=False)\n",
    "X_train, X_cv, y_train, y_cv = train_test_split(X_train, y_train, test_size=0.20, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train Observations: 561413\n",
      "y_train Observations: 561413\n",
      "X_cv Observations: 140354\n",
      "y_cv Observations: 140354\n",
      "X_test Observations: 175442\n",
      "y_test Observations: 175442\n"
     ]
    }
   ],
   "source": [
    "print('X_train Observations: %d' % (len(X_train)))\n",
    "print('y_train Observations: %d' % (len(y_train)))\n",
    "\n",
    "print('X_cv Observations: %d' % (len(X_cv)))\n",
    "print('y_cv Observations: %d' % (len(y_cv)))\n",
    "\n",
    "print('X_test Observations: %d' % (len(X_test)))\n",
    "print('y_test Observations: %d' % (len(y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reference: AAIC Case_study_2.\n",
    "# This function plots the confusion matrices given y_i, y_i_hat.\n",
    "from sklearn.metrics import confusion_matrix, recall_score, accuracy_score, precision_score\n",
    "def plot_confusion_matrix(test_y, predict_y):\n",
    "    C = confusion_matrix(test_y, predict_y)\n",
    "    A =(((C.T)/(C.sum(axis=1))).T)\n",
    "    B =(C/C.sum(axis=0))\n",
    "    \n",
    "    labels = ['comp1', 'comp2', 'comp3', 'comp4', 'none']\n",
    "    # representing A in heatmap format\n",
    "    print(\"-\"*20, \"Confusion matrix\", \"-\"*20)\n",
    "    plt.figure(figsize=(20,7))\n",
    "    sns.heatmap(C, annot=True, cmap=\"YlGnBu\", fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.show()\n",
    "\n",
    "    print(\"-\"*20, \"Precision matrix (Columm Sum=1)\", \"-\"*20)\n",
    "    plt.figure(figsize=(20,7))\n",
    "    sns.heatmap(B, annot=True, cmap=\"YlGnBu\", fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.show()\n",
    "    \n",
    "    # representing B in heatmap format\n",
    "    print(\"-\"*20, \"Recall matrix (Row sum=1)\", \"-\"*20)\n",
    "    plt.figure(figsize=(20,7))\n",
    "    sns.heatmap(A, annot=True, cmap=\"YlGnBu\", fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apply model XGBClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\medinikb\\Anaconda3\\lib\\site-packages\\xgboost\\sklearn.py:1146: UserWarning: The use of label encoder in XGBClassifier is deprecated and will be removed in a future release. To remove this warning, do the following: 1) Pass option use_label_encoder=False when constructing XGBClassifier object; and 2) Encode your labels (y) as integers starting with 0, i.e. 0, 1, 2, ..., [num_class - 1].\n",
      "  warnings.warn(label_encoder_deprecation_msg, UserWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[21:43:02] WARNING: C:/Users/Administrator/workspace/xgboost-win64_release_1.4.0/src/learner.cc:1095: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'multi:softprob' was changed from 'merror' to 'mlogloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n",
       "              colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,\n",
       "              importance_type='gain', interaction_constraints='',\n",
       "              learning_rate=0.300000012, max_delta_step=0, max_depth=6,\n",
       "              min_child_weight=1, missing=nan, monotone_constraints='()',\n",
       "              n_estimators=100, n_jobs=8, num_parallel_tree=1,\n",
       "              objective='multi:softprob', random_state=0, reg_alpha=0,\n",
       "              reg_lambda=1, scale_pos_weight=None, subsample=1,\n",
       "              tree_method='exact', validate_parameters=1, verbosity=None)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from xgboost import XGBClassifier\n",
    "\n",
    "x_cfl=XGBClassifier()\n",
    "x_cfl.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------- Confusion matrix --------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------- Precision matrix (Columm Sum=1) --------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------- Recall matrix (Row sum=1) --------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(y_test, x_cfl.predict(X_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apply model Random Forest Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 39.4 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(n_jobs=-1)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "r_cfl=RandomForestClassifier(n_jobs=-1)\n",
    "r_cfl.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------- Confusion matrix --------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------- Precision matrix (Columm Sum=1) --------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------- Recall matrix (Row sum=1) --------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(y_test, r_cfl.predict(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------------------------------------------+-------+-------+-------+-------+---------------+\n",
      "|          Model name (Recall score )          | comp1 | comp2 | comp3 | comp4 | none(no fail) |\n",
      "+----------------------------------------------+-------+-------+-------+-------+---------------+\n",
      "|    Xgboost without hyper-parameter tuning    | 0.206 | 0.366 | 0.639 | 0.556 |       1       |\n",
      "| Random Forest without hyper-parameter tuning | 0.206 | 0.427 | 0.672 | 0.611 |       1       |\n",
      "+----------------------------------------------+-------+-------+-------+-------+---------------+\n"
     ]
    }
   ],
   "source": [
    "from prettytable import PrettyTable\n",
    "\n",
    "# Specify the Column Names\n",
    "myTable = PrettyTable([\"Model name (Recall score )\", \"comp1\", \"comp2\", \"comp3\", 'comp4', 'none(no fail)'])\n",
    "\n",
    "# Add rows\n",
    "myTable.add_row([\"Xgboost without hyper-parameter tuning\", \n",
    "                 \"0.206\", \"0.366\", \"0.639\", \"0.556\", \"1\"])\n",
    "\n",
    "\n",
    "myTable.add_row([\"Random Forest without hyper-parameter tuning\", \n",
    "                 \"0.206\", \"0.427\", \"0.672\", \"0.611\", \"1\"])\n",
    "\n",
    "\n",
    "print(myTable)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Observations on First cut approach:\n",
    "    1. The Recall value of Xgboost and Random Forest model are satisfactory without performing the feature engineering and hyper-parameter tuning. \n",
    "    2. After performing EDA, it is observed that this problem can be modeled as time series          problem.\n",
    "    3. To increase the performance of the ML models, it is better to perform time series          feature engineering technique and do hyper-parameter tuning in the next step. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# >>>>> End of note book <<<<<<"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}