FactoryIO_JenksTrainingData.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"color:green;\">SCREENSHOT OF RUNNING SCENE IN FACTORY IO</h3>\n",
    "<p>Factory I/O is a 3D factory simulation for learning automation technologies. Designed to be easy to use, it allows to quickly build a virtual factory using a selection of common industrial parts.\n",
    "\n",
    "Factory I/O also includes many scenes inspired by typical industrial applications, ranging from beginner to advanced difficulty levels.\n",
    "\n",
    "The most common scenario is to use Factory I/O as a PLC training platform since PLC are the most common controllers found in industrial applications. However, it can also be used with microcontrollers, SoftPLC, Modbus, among many other technologies.</p>\n",
    "\n",
    "<a href=\"url\">https://factoryio.com/</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](images/Conveyor.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"color:green;\">SCREENSHOT OF CONTROL IO CONFIGURATOR</h3>\n",
    "<p>CONTROL I/O is an easy to use, brand independent SoftPLC, designed from the ground up for FACTORY I/O.<br> The goal of CONTROL I/O is to provide a simple and intuitive experience for anyone starting in the world of automation.</p>\n",
    "<a href=\"url\">https://docs.factoryio.com</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](images/Control_IO.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"color:green;\">Finding the ideal range of time between boxes using idealistic data<h3>\n",
    "<p style=\"font-weight: normal;\">Using exported tags from Factory IO to determine optimal working parameters for conveyor.</p>\n",
    "<p style=\"font-weight: normal;\">The PNOZmulti Analog Sensor block already has the concept of a working range for an analog sensor. \n",
    "This is largely a solved problem, engineers normally use the Namur standard current range but finding the working range for a new process is not so easy.</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](images/workingRange.PNG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing the csv file created in factory io\n",
    "#File currently contains 6 Columns and 682,211 Rows\n",
    "data = pd.read_csv('data/normal.zip')\n",
    "df = pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing the csv file from factory io\n",
    "\n",
    "#Commenting out block of code for local machine usage\n",
    "#data = pd.read_csv('C:/Users/a.sethu/Desktop/Python/normal.csv')\n",
    "#df = pd.DataFrame(data)\n",
    "\n",
    "#Importing the csv file created in factory io\n",
    "#File currently contains 6 Columns and 682,211 Rows\n",
    "import zipfile\n",
    "from zipfile import ZipFile\n",
    "file_name = \"data/normal.zip\"\n",
    "with ZipFile(file_name, 'r') as zip:\n",
    "    # printing all the contents of the zip file\n",
    "    zip.printdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"color:green;\">ISOLATING RELEVANT TAG DATA.<h3>\n",
    "<p style=\"font-weight: normal;\">For our purposes we only require the sensor data specific to the light array emitter.</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Subseting all Light Array Emitter data\n",
    "filteredLAE = df[df[' Name']=='Light Array Emitter 1 (Value)']\n",
    "#using a copy to prevent index warning\n",
    "filteredLAE = filteredLAE.copy()\n",
    "#converting the current value column to numeric\n",
    "filteredLAE[' Current Value'] = pd.to_numeric(filteredLAE[' Current Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using a copy to prevent index warning\n",
    "filteredLAE = filteredLAE.copy()\n",
    "filteredLAE[' Sensor Value Difference'] = filteredLAE[' Current Value'].diff()\n",
    "filteredLAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Filtering sensor trigger data points from the data by removing \n",
    "#all all data with current value = 0\n",
    "filteredLAE = filteredLAE[filteredLAE[' Sensor Value Difference'] != 0]\n",
    "filteredLAE = filteredLAE[filteredLAE[' Current Value']!=128 ]\n",
    "filteredLAE = filteredLAE[filteredLAE[' Current Value']!=64 ]\n",
    "#Dropping al NaN values\n",
    "filteredLAE.dropna(subset = [' Sensor Value Difference'], inplace=True)\n",
    "filteredLAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filteredLAE[filteredLAE[' Sensor Value Difference'] > 0]\n",
    "filteredLAE['Trigger Status']=\"Off\"\n",
    "filteredLAE['Trigger Status'] = filteredLAE.apply(lambda x: 'On' if x[' Sensor Value Difference']>0 else 'Off',axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filteredLAE['Trigger Interval'] = filteredLAE[\" Time Elapsed\"].diff(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preprocessedDF = filteredLAE[filteredLAE['Trigger Status']=='On']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using a copy to prevent index warning\n",
    "preprocessedDF = preprocessedDF.copy()\n",
    "preprocessedDF['Trigger Interval'] = preprocessedDF[\" Time Elapsed\"].diff(1)\n",
    "preprocessedDF.dropna(subset = ['Trigger Interval'], inplace=True)\n",
    "preprocessedDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import seaborn as sns\n",
    "preprocessedDF=preprocessedDF.reset_index(drop=True)\n",
    "plt.figure(figsize=(12,8)) #Plotting the data points on the plot\n",
    "sns.stripplot(x='Trigger Interval',data = preprocessedDF,jitter= True,edgecolor = 'None')\n",
    "sns.despine\n",
    "locs,labels = plt.xticks()\n",
    "plt.yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"color:green;\">Using Jenks Natural Optimisation Method for finding the range <h3>\n",
    "<p style=\"font-weight: normal;\">The Jenks optimization method, also called the Jenks natural breaks classification method, is a data clustering method designed to determine the best arrangement of values into different classes.\n",
    "    </p>\n",
    "<p style=\"font-weight: normal;\">This is done by seeking to minimize each class's average deviation from the class mean, while maximizing each class's deviation from the means of the other classes.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import jenkspy\n",
    "#Finding the breaks using the Jenks natural breaks optimzation method\n",
    "breaks = jenkspy.jenks_breaks(preprocessedDF['Trigger Interval'],nb_class = 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "breaks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#seaborn library for plotting\n",
    "import seaborn as sns\n",
    "plt.figure(figsize=(12,8)) #Plotting the data points on the plot\n",
    "sns.stripplot(x='Trigger Interval',data = preprocessedDF,jitter= True,edgecolor = 'None')\n",
    "sns.despine\n",
    "locs,labels = plt.xticks()\n",
    "plt.yticks([])\n",
    "#Drawing vertical lines usng the data points as x values\n",
    "for b in breaks:\n",
    "    plt.vlines(b,ymin= -0.2,ymax=0.2,color='k')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 style=\"color:green;\">Conclusion<h3>\n",
    "<p style=\"font-weight: normal;\">The range obtained from JNBO indicates that the ideal range lies between 4.5 and 5.8.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rangeIndexStart = int(len(breaks)/2)\n",
    "download_list = []\n",
    "download_list.append(breaks[rangeIndexStart-1])\n",
    "download_list.append(breaks[rangeIndexStart])\n",
    "#Downloading the range of values at the center of the plot\n",
    "import pickle\n",
    "filename = 'data/finalized_model.sav'\n",
    "pickle.dump(download_list, open(filename, 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}