cleaning_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cleaning data (detection of outliers) using one class SVM "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\nu$ proportion of outliers must be defined by the user. It is an input of the model\n",
    "similarly the choice of the kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries, seaborn and sys can be removed. Oher must be kept\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import sklearn\n",
    "import sys\n",
    "sns.set(color_codes=True)\n",
    "%matplotlib inline\n",
    "\n",
    "# import tools from sklearn library\n",
    "\n",
    "from sklearn.svm import OneClassSVM\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "#import library for reading files in a specific directory\n",
    "\n",
    "import os\n",
    "\n",
    "# import tools from csv library in order to read and write a new csv file\n",
    "\n",
    "from csv import reader\n",
    "from csv import writer\n",
    "\n",
    "# import library in order to move file to a desire location\n",
    "\n",
    "import shutil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data cleaning to all data sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n",
      "data_0.5125_1.csv\n",
      "data_0.525_1.csv\n",
      "data_0.5375_1.csv\n",
      "data_0.55_1.csv\n",
      "data_0.5625_1.csv\n",
      "data_0.575_1.csv\n",
      "data_0.5875_1.csv\n",
      "data_0.5_1.csv\n",
      "data_0.6125_1.csv\n",
      "data_0.625_1.csv\n",
      "data_0.6375_1.csv\n",
      "data_0.65_1.csv\n",
      "data_0.6625_1.csv\n",
      "data_0.675_1.csv\n",
      "data_0.6875_1.csv\n",
      "data_0.6_1.csv\n",
      "data_0.7125_1.csv\n",
      "data_0.725_1.csv\n",
      "data_0.7375_1.csv\n",
      "data_0.75_1.csv\n",
      "data_0.7_1.csv\n",
      "data_0.8_1.csv\n",
      "data_0.9_1.csv\n",
      "data_1.0_1.csv\n",
      "data_1.1_1.csv\n",
      "data_1.2_1.csv\n",
      "data_1.3_1.csv\n",
      "data_1.4_1.csv\n",
      "data_1.5_1.csv\n",
      "data_1.6_1.csv\n",
      "data_1.7_1.csv\n",
      "data_1.8_1.csv\n"
     ]
    }
   ],
   "source": [
    "# count the file in location 'Data/Data_svenja_csv'. This folder contains csv files with original data\n",
    "# This location can be changed by the user.\n",
    "\n",
    "max=0\n",
    "for files in os.listdir('Data/Data_svenja_csv'):\n",
    "    max=max+1\n",
    "print(max) # check the number of files in that location\n",
    "\n",
    "# removing outliers/anomalies\n",
    "\n",
    "for j in range(1,max):\n",
    "    name=os.listdir('Data/Data_svenja_csv')[j] #reading name of csv file j at location 'Data/Data_svenja_csv'\n",
    "    print(name)  #check that files have been reading correctly\n",
    "    dataset=pd.read_csv(name,header=None) # read csv file using pandas\n",
    "    X1=dataset.values[:,[0,4,5]]          # convert to array inputs and time in csv file j \n",
    "    \n",
    "    # rescale data to a new data with mean value=0 and standard deviation 1\n",
    "    sc_input=StandardScaler()  # instantiate StandardScaler\n",
    "    X1_scale=sc_input.fit_transform(X1) #fit StandardScaler to data set\n",
    "    outliers_fraction=0.35        #proportion of outliers defined by the user. Default values by the program is 0.5\n",
    "    \n",
    "    #defining One-class SVM model: kernel='rbf' is the most robust, other kernels that can be used are:\n",
    "    # linear = ‘linear’, \n",
    "    # polynomial = ‘poly’ if this is used , it must be added the degree of the polynomial:degree=value (default=3)\n",
    "    #‘sigmoid’ for probabilistic problems, \n",
    "    #‘precomputed’ kernel predifing by the user as a function\n",
    "    # also a linear combination de ellos could be considered, for instance: kernel=0.5*'rbf'+0.5*'linear'\n",
    "    # nu=outliers_fraction : proportion of outliers defined by the user\n",
    "    # gamma='scale' considering the predefined scale. Do not change it\n",
    "    \n",
    "    clf1 = OneClassSVM(kernel='rbf',nu=outliers_fraction,gamma='scale').fit(X1_scale[:,[0,1]]) #fit One-class SVM to time and air volumetric flow\n",
    "    z1=clf1.predict(X1_scale[:,[0,1]])  # separate inliers from outliers\n",
    "    \n",
    "    # remove outlier from data set\n",
    "    \n",
    "    # first create a new file where inliers will be added\n",
    "    # open('file name,r') open original csv file (before removing outliers)\n",
    "    # open(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'.csv', 'w', newline='') as write_obj:it\n",
    "    # opens a new csv file called 'name.split('.')[0]'+'name.split('.')[1]+'_'+str(outliers_fraction)+'.csv'\n",
    "    # for instance 'data_1'+'2_1'+'_'+'proportion of outliers'+'.csv'\n",
    "    # this file is open and prepared for writing over it the inliers\n",
    "    with open(name, 'r') as read_obj,\\\n",
    "        open(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'.csv', 'w', newline='') as write_obj:\n",
    "    # Create a csv.reader object from the input file object\n",
    "        csv_reader = reader(read_obj)\n",
    "    # Create a csv.writer object from the output file object\n",
    "        csv_writer = writer(write_obj)\n",
    "    # Read each row of the input csv file as list\n",
    "        i=0\n",
    "        for row in csv_reader:\n",
    "            if (z1[i]!=[-1]):            #if data is not classified as outliers, it will be written in the new file\n",
    "                csv_writer.writerow(row) #adding row to the new file\n",
    "            i=i+1\n",
    "    \n",
    "    # after removing outliers respect to oxigen, we will do the same with respect to hidrogen\n",
    "    # proportion of outliers must be provided by the user. Here it is considered nu=0.05\n",
    "    # the following steps are the similar to the previous ones\n",
    "    \n",
    "    # read new csv file where points after removing outliers with respect air are stored\n",
    "    X2=pd.read_csv(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'.csv',header=None).values[:,[0,4,5]]\n",
    "    sc_input=StandardScaler()  #instantiate StandardScaler\n",
    "    X2_scale=sc_input.fit_transform(X2)  #fit model to the data set\n",
    "    outliers_fraction2=0.05              #define proportion of outliers\n",
    "    # define One-Class SVM model\n",
    "    clf2 = OneClassSVM(kernel='rbf',nu=outliers_fraction2,gamma='scale').fit(X2_scale[:,[0,2]])\n",
    "    z2=clf2.predict(X2_scale[:,[0,2]]) # classify inliers from outliers \n",
    "    \n",
    "    #open file with data after removing outliers with respect to oxigen\n",
    "    #open new file where we will add inliers after removing outliers respect to hidrogen\n",
    "    #new file name has the following shape 'data_eq.ratio_1_proportion outlier oxigen_porportion  outlier hydrogen'\n",
    "    #name can be changed by the user\n",
    "    \n",
    "    with open(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'.csv', 'r') as read_obj, \\\n",
    "        open(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'_'+str(outliers_fraction2)+'.csv', 'w', newline='') as write_obj:\n",
    "    # Create a csv.reader object from the input file object\n",
    "        csv_reader = reader(read_obj)\n",
    "    # Create a csv.writer object from the output file object\n",
    "        csv_writer = writer(write_obj)\n",
    "    # Read each row of the input csv file as list\n",
    "        i=0\n",
    "        for row in csv_reader:  \n",
    "            if (z2[i]!=[-1]):       # if point is classified as inlier, it will be written in the new csv file\n",
    "                csv_writer.writerow(row)\n",
    "            i=i+1\n",
    "    \n",
    "    # new files are created at the location where the python file is. We use shutil to move them to a \n",
    "    # new location 'Data/Data_svenja_clean_0.4' \n",
    "    newPath = shutil.copy(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'_'+str(outliers_fraction2)+'.csv', 'Data/Data_svenja_clean_0.4')\n",
    "    #remove temporary and new files that were created at python location in order to save memory.\n",
    "    os.remove(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'_'+str(outliers_fraction2)+'.csv')\n",
    "    os.remove(name.split('.')[0]+'.'+name.split('.')[1]+'_'+str(outliers_fraction)+'.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Join new data files creating after removing outliers in a single csv file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries that will be used to read and join csv file \n",
    "import glob  # library for joning multiples csv files \n",
    "import csv   # library for manipulating csv files\n",
    "\n",
    "# directory where csv files are stored\n",
    "Dir = \"C:/Users/MOC1DEV/Data/Data_svenja_clean_0.4\"\n",
    "# directory where a new single file with the whole data points will be stored\n",
    "# it can be changed by the user\n",
    "Avg_Dir = \"C:/Users/MOC1DEV/Data\"\n",
    "\n",
    "# read csv files in directory Dir\n",
    "csv_file_list = glob.glob(os.path.join(Dir, '*.csv')) # returns the file list\n",
    "#print (csv_file_list) # optional for checking list of csv files\n",
    "\n",
    "# open new single file where data points after reomving outlier will be stored\n",
    "# open(os.path.join(Avg_Dir, 'new name.csv'), 'w', newline='') as f: \n",
    "# new name can be changed. 'w' and newline='' should not be changed\n",
    "with open(os.path.join(Avg_Dir, 'Output_clean.csv'), 'w', newline='') as f:\n",
    "    wf = csv.writer(f, lineterminator='\\n') # open new single csv file and prepare it to write over it \n",
    "                                            # '\\n' should not be changed.\n",
    "    for files in csv_file_list:\n",
    "        with open(files, 'r') as r: \n",
    "            next(r)                   # SKIP HEADERS\n",
    "            rr = csv.reader(r)        #read csv file in csv_file_list\n",
    "            for row in rr:\n",
    "                wf.writerow(row)      #add row to new single csv file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing mean, standard deviations and coefficient of variation in order to compare results \n",
    "before and after removing outliers/anomalies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n",
      "data_0.5125_1_0.35_0.05.csv\n",
      "data_0.525_1_0.35_0.05.csv\n",
      "data_0.5375_1_0.35_0.05.csv\n",
      "data_0.55_1_0.35_0.05.csv\n",
      "data_0.5625_1_0.35_0.05.csv\n",
      "data_0.575_1_0.35_0.05.csv\n",
      "data_0.5875_1_0.35_0.05.csv\n",
      "data_0.5_1_0.35_0.05.csv\n",
      "data_0.6125_1_0.35_0.05.csv\n",
      "data_0.625_1_0.35_0.05.csv\n",
      "data_0.6375_1_0.35_0.05.csv\n",
      "data_0.65_1_0.35_0.05.csv\n",
      "data_0.6625_1_0.35_0.05.csv\n",
      "data_0.675_1_0.35_0.05.csv\n",
      "data_0.6875_1_0.35_0.05.csv\n",
      "data_0.6_1_0.35_0.05.csv\n",
      "data_0.7125_1_0.35_0.05.csv\n",
      "data_0.725_1_0.35_0.05.csv\n",
      "data_0.7375_1_0.35_0.05.csv\n",
      "data_0.75_1_0.35_0.05.csv\n",
      "data_0.7_1_0.35_0.05.csv\n",
      "data_0.8_1_0.35_0.05.csv\n",
      "data_0.9_1_0.35_0.05.csv\n",
      "data_1.0_1_0.35_0.05.csv\n",
      "data_1.1_1_0.35_0.05.csv\n",
      "data_1.2_1_0.35_0.05.csv\n",
      "data_1.3_1_0.35_0.05.csv\n",
      "data_1.4_1_0.35_0.05.csv\n",
      "data_1.5_1_0.35_0.05.csv\n",
      "data_1.6_1_0.35_0.05.csv\n",
      "data_1.7_1_0.35_0.05.csv\n",
      "data_1.8_1_0.35_0.05.csv\n"
     ]
    }
   ],
   "source": [
    "max=0\n",
    "for files in os.listdir('Data/Data_svenja_clean_0.4'):\n",
    "    max=max+1\n",
    "print(max)\n",
    "mean_air_clean=[] #create list for mean volumetric flow air after removing outliers\n",
    "std_air_clean=[]  #create list for standard deviation air after removing outliers\n",
    "CV_air_clean=[]   #create list for coefficient of variation after removing outliers\n",
    "mean_H2_clean=[]  #create list for mean volumetric flow hydrogen after removing outliers\n",
    "std_H2_clean=[]   #create list for standard deviation hydrogen removing outliers\n",
    "CV_H2_clean=[]   #create list for coefficient of variation after removing outliers\n",
    "mean_ratio_clean=[]  #create list for mean equivalence ratio after removing outliers\n",
    "std_ratio_clean=[]  #create list for standard deviation equivalence ratio after removing outliers\n",
    "CV_ratio_clean=[]  #create list for coefficient of variation equivalence ratio after removing outliers\n",
    "mean_sensor_clean=[] #create list for mean sensor measurement after removing outliers\n",
    "std_sensor_clean=[]  #create list for standard deviation sensor mesurement after removing outliers\n",
    "CV_sensor_clean=[] #create list for coefficient of variation sensor measurement after removing outliers\n",
    "\n",
    "# read each data set created after removing outliers and compute the mean, standard deviation anc CV\n",
    "for j in range(1,max):\n",
    "    name=os.listdir('Data/Data_svenja_clean_0.4')[j] #location where files after removing outliers are stored \n",
    "    print(name)  #check that program is reading whole files at the given location\n",
    "    dataset=pd.read_csv('Data/Data_svenja_clean_0.4/'+name,header=None) #read csv file\n",
    "    X1=dataset.values[:,:]    #converting information to arrays\n",
    "    mean1=np.mean(X1[:,4])    #computing mean values air\n",
    "    std1=np.std(X1[:,4])      #computing standard deviation of air\n",
    "    CV1=std1/mean1            #computing coefficient of variation : standard deviation/mean value\n",
    "    mean_air_clean.append(mean1) #add mean air volumetric flow to a list\n",
    "    std_air_clean.append(std1)   #add standard deviation air volumetric flow to a list\n",
    "    CV_air_clean.append(CV1)   #add cv air volumetric flow to a list\n",
    "    mean1=np.mean(X1[:,5])    #repeat the previous step for hydrogen volumetric flow\n",
    "    std1=np.std(X1[:,5])\n",
    "    CV1=std1/mean1\n",
    "    mean_H2_clean.append(mean1)\n",
    "    std_H2_clean.append(std1)\n",
    "    CV_H2_clean.append(CV1)\n",
    "    mean1=np.mean(X1[:,3])  #repeat the previous step for sensor measurement\n",
    "    std1=np.std(X1[:,3])\n",
    "    CV1=std1/mean1\n",
    "    mean_sensor_clean.append(mean1)\n",
    "    std_sensor_clean.append(std1)\n",
    "    CV_sensor_clean.append(CV1)\n",
    "    mean1=np.mean(X1[:,10]) #repeat previous step for equivalence ratios\n",
    "    std1=np.std(X1[:,10])\n",
    "    CV1=std1/mean1\n",
    "    mean_ratio_clean.append(mean1)\n",
    "    std_ratio_clean.append(std1)\n",
    "    CV_ratio_clean.append(CV1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n",
      "data_0.5125_1.csv\n",
      "data_0.525_1.csv\n",
      "data_0.5375_1.csv\n",
      "data_0.55_1.csv\n",
      "data_0.5625_1.csv\n",
      "data_0.575_1.csv\n",
      "data_0.5875_1.csv\n",
      "data_0.5_1.csv\n",
      "data_0.6125_1.csv\n",
      "data_0.625_1.csv\n",
      "data_0.6375_1.csv\n",
      "data_0.65_1.csv\n",
      "data_0.6625_1.csv\n",
      "data_0.675_1.csv\n",
      "data_0.6875_1.csv\n",
      "data_0.6_1.csv\n",
      "data_0.7125_1.csv\n",
      "data_0.725_1.csv\n",
      "data_0.7375_1.csv\n",
      "data_0.75_1.csv\n",
      "data_0.7_1.csv\n",
      "data_0.8_1.csv\n",
      "data_0.9_1.csv\n",
      "data_1.0_1.csv\n",
      "data_1.1_1.csv\n",
      "data_1.2_1.csv\n",
      "data_1.3_1.csv\n",
      "data_1.4_1.csv\n",
      "data_1.5_1.csv\n",
      "data_1.6_1.csv\n",
      "data_1.7_1.csv\n",
      "data_1.8_1.csv\n"
     ]
    }
   ],
   "source": [
    "# repeat the same procedure explained above for data before removing outliers\n",
    "max=0\n",
    "for files in os.listdir('Data/Data_svenja_csv'):\n",
    "    max=max+1\n",
    "print(max)\n",
    "mean_air_unclean=[]\n",
    "std_air_unclean=[]\n",
    "CV_air_unclean=[]\n",
    "mean_H2_unclean=[]\n",
    "std_H2_unclean=[]\n",
    "CV_H2_unclean=[]\n",
    "mean_ratio_unclean=[]\n",
    "std_ratio_unclean=[]\n",
    "CV_ratio_unclean=[]\n",
    "mean_sensor_unclean=[]\n",
    "std_sensor_unclean=[]\n",
    "CV_sensor_unclean=[]\n",
    "for j in range(1,max):\n",
    "    name=os.listdir('Data/Data_svenja_csv')[j]\n",
    "    print(name)\n",
    "    dataset=pd.read_csv(name,header=None)\n",
    "    X1=dataset.values[:,:]\n",
    "    mean1=np.mean(X1[:,4])\n",
    "    std1=np.std(X1[:,4])\n",
    "    CV1=std1/mean1\n",
    "    mean_air_unclean.append(mean1)\n",
    "    std_air_unclean.append(std1)\n",
    "    CV_air_unclean.append(CV1)\n",
    "    mean1=np.mean(X1[:,5])\n",
    "    std1=np.std(X1[:,5])\n",
    "    CV1=std1/mean1\n",
    "    mean_H2_unclean.append(mean1)\n",
    "    std_H2_unclean.append(std1)\n",
    "    CV_H2_unclean.append(CV1)\n",
    "    mean1=np.mean(X1[:,3])\n",
    "    std1=np.std(X1[:,3])\n",
    "    CV1=std1/mean1\n",
    "    mean_sensor_unclean.append(mean1)\n",
    "    std_sensor_unclean.append(std1)\n",
    "    CV_sensor_unclean.append(CV1)\n",
    "    mean1=np.mean(X1[:,10])\n",
    "    std1=np.std(X1[:,10])\n",
    "    CV1=std1/mean1\n",
    "    mean_ratio_unclean.append(mean1)\n",
    "    std_ratio_unclean.append(std1)\n",
    "    CV_ratio_unclean.append(CV1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#equivalence ratios must be reordered in an increasing way\n",
    "#this routine is for reordered equivalence ratios and their respective statistical measures before removing outliers\n",
    "\n",
    "temp1 = 0 \n",
    "temp2 = 0\n",
    "temp3 = 0\n",
    "for i in range(0, len(mean_ratio_unclean)):  \n",
    "    for j in range(i+1, len(mean_ratio_unclean)):  #compare value at i position with the following values\n",
    "        if(mean_ratio_unclean[i] > mean_ratio_unclean[j]): #check if the eq.ratio is larger than the next one\n",
    "            temp1 = mean_ratio_unclean[i]                  #redefine temp in order to save the value at i position\n",
    "            mean_ratio_unclean[i] = mean_ratio_unclean[j]  #change smaller value to i position\n",
    "            mean_ratio_unclean[j] = temp1                  #move larger value to j position\n",
    "            temp2 = CV_sensor_unclean[i]                   #change the respective statistical measures\n",
    "            CV_sensor_unclean[i] = CV_sensor_unclean[j]  \n",
    "            CV_sensor_unclean[j] = temp2\n",
    "            temp3 = CV_ratio_unclean[i] \n",
    "            CV_ratio_unclean[i] = CV_ratio_unclean[j]  \n",
    "            CV_ratio_unclean[j] = temp3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#repeat the same procedure for statistical measures after removing outliers\n",
    "\n",
    "temp1 = 0 \n",
    "temp2 = 0\n",
    "temp3 = 0\n",
    "for i in range(0, len(mean_ratio_clean)):  \n",
    "    for j in range(i+1, len(mean_ratio_clean)):  \n",
    "        if(mean_ratio_clean[i] > mean_ratio_clean[j]):  \n",
    "            temp1 = mean_ratio_clean[i] \n",
    "            mean_ratio_clean[i] = mean_ratio_clean[j]  \n",
    "            mean_ratio_clean[j] = temp1\n",
    "            temp2 = CV_sensor_clean[i] \n",
    "            CV_sensor_clean[i] = CV_sensor_clean[j]  \n",
    "            CV_sensor_clean[j] = temp2\n",
    "            temp3 = CV_ratio_clean[i] \n",
    "            CV_ratio_clean[i] = CV_ratio_clean[j]  \n",
    "            CV_ratio_clean[j] = temp3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "plot coefficient of variation for equivalence ratios and sensor mesurements before and after removing outliers for each data set represented by its recomputed mean equivalence ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (12,8))  #define figure and size (it can be changed by the user)\n",
    "ax = fig.add_subplot(1, 2, 1)       #define two subplot (two figures joing together)\n",
    "ax.plot(mean_ratio_unclean, CV_ratio_unclean, color='b',label='before removing outliers') #graph line before removing outliers\n",
    "ax.plot(mean_ratio_clean, CV_ratio_clean, color='r', label='after removing outliers') #graph line after removing outliers\n",
    "ax.set_xlabel('Equivalence ratios[-]',fontsize=15)                                   #define x label\n",
    "ax.set_ylabel('Coefficient of variation Equivalence Ratios [-]',fontsize=15)         #define y label\n",
    "ax.set_title('Coefficient of variation Equivalence Ratios ',fontsize=15)             #define title\n",
    "plt.legend(loc='upper left',fontsize=15)           #insert legend upper left(position can be changed by the user)\n",
    "#repeat the same procedure explained above for sensor measurements\n",
    "ax=fig.add_subplot(1,2,2)\n",
    "ax.plot(mean_ratio_unclean, CV_sensor_unclean, color='b',label='before removing outliers')\n",
    "ax.plot(mean_ratio_clean, CV_sensor_clean, color='r',label='after removing outliers')\n",
    "ax.set_xlabel('Equivalence ratios[-]',fontsize=15)\n",
    "ax.set_ylabel('Coefficient of variation Sensor Measurements [-]',fontsize=15)\n",
    "ax.set_title('Coefficient of variation Sensor Measurements',fontsize=15)\n",
    "plt.legend(loc='upper left',fontsize=15)\n",
    "fig.subplots_adjust(hspace=.5,wspace=0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5292221663996601 0.52966381626468\n",
      "0.0040903766757469946 0.001332396590889283\n"
     ]
    }
   ],
   "source": [
    "# print some values for checking that program is running properly, they can be omitted by the user\n",
    "print(mean_ratio_unclean[0],mean_ratio_clean[0])\n",
    "print(CV_ratio_unclean[0],CV_ratio_clean[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}