Part3_Comparing direct demand to constarint approach with proposed algorithm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39\n",
      "46\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "#remove the row and column label from excel sheet before loading\n",
    "\n",
    "#dataset import for regressor\n",
    "X_dem=pd.read_excel(r'C:\\Users\\fhasan1\\dataset39.xlsx', header=None, sheet_name=0)\n",
    "y_gen=pd.read_excel(r'C:\\Users\\fhasan1\\dataset39.xlsx', header=None, sheet_name=1)\n",
    "\n",
    "#Changing pandas dataframe to numpy array\n",
    "X_dem = X_dem.to_numpy()\n",
    "y_gen = y_gen.to_numpy()\n",
    "\n",
    "# load new voltage and brnach status dataset for classification\n",
    "y_bus=pd.read_excel(r'C:\\Users\\fhasan1\\dataset39.xlsx', header=None, sheet_name=2)#outputbus\n",
    "y_branch=pd.read_excel(r'C:\\Users\\fhasan1\\dataset39.xlsx', header=None, sheet_name=3)#outputbranch\n",
    "\n",
    "#Changing pandas dataframe to numpy array\n",
    "y_bus = y_bus.to_numpy()\n",
    "y_branch = y_branch.to_numpy()\n",
    "\n",
    "# Generator bus indices\n",
    "Gen_index=pd.read_excel(r'C:\\Users\\fhasan1\\dataset39.xlsx', header=None, sheet_name=4)\n",
    "Gen_index=np.array(Gen_index)\n",
    "\n",
    "# Loading Index_of_nonzero_nodal_demand\n",
    "load_index=pd.read_excel(r'C:\\Users\\fhasan1\\dataset39.xlsx', header=None, sheet_name=5)\n",
    "load_index=np.array(load_index)\n",
    "load_index=load_index-1 #as pyhton starts counting from zero\n",
    "load_index=load_index.T\n",
    "\n",
    "#number bus branch and gen\n",
    "nb=np.size(y_bus,1)#bus\n",
    "nl=np.size(y_branch,1)#branch\n",
    "ng=len(Gen_index)#gen\n",
    "\n",
    "print(nb)\n",
    "print(nl)\n",
    "print(ng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# load and evaluate a saved model\n",
    "from keras.models import load_model\n",
    " \n",
    "# load model\n",
    "modelG = load_model('modelG_39.h5')\n",
    "modelV = load_model('modelV_39.h5')\n",
    "modelB = load_model('modelB_39.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2000, 78)\n",
      "(2000, 39)\n",
      "(2000, 46)\n"
     ]
    }
   ],
   "source": [
    "#dataset for classifier trainig\n",
    "X_classifier=X_dem[2000:4000,0:]\n",
    "y_classifier_bus=y_bus[2000:4000,0:]\n",
    "y_classifier_branch=y_branch[2000:4000,0:]\n",
    "print(X_classifier.shape)\n",
    "print(y_classifier_bus.shape)\n",
    "print(y_classifier_branch.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2000, 42)\n",
      "(2000, 78)\n"
     ]
    }
   ],
   "source": [
    "# Generation prediction\n",
    "X_classifier_dem=np.copy(X_classifier)\n",
    "X_classifier_dem=X_classifier_dem[:,load_index[0,0:]]  \n",
    "\n",
    "print(X_classifier_dem.shape)\n",
    "print(X_classifier.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Train test split of model\n",
    "from sklearn.model_selection import train_test_split\n",
    "# model for voltage\n",
    "X_trainV,X_testV,y_trainV,y_testV = train_test_split(X_classifier_dem,y_classifier_bus,test_size = 0.1,random_state = 0)\n",
    "# model for branch\n",
    "X_trainB,X_testB,y_trainB,y_testB = train_test_split(X_classifier_dem,y_classifier_branch,test_size = 0.1,random_state = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#bus slassifier model\n",
    "modelDV = Sequential()\n",
    "modelDV.add(Dense(256, input_dim=np.size(X_classifier_dem,1), activation='sigmoid'))\n",
    "modelDV.add(Dense(nb, activation='softmax'))\n",
    "modelDV.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "\n",
    "#branch slassifier model\n",
    "modelDB = Sequential()\n",
    "modelDB.add(Dense(256, input_dim=np.size(X_classifier_dem,1), activation='sigmoid'))\n",
    "modelDB.add(Dense(nl, activation='softmax'))\n",
    "modelDB.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "historyDV = modelDV.fit(X_trainV, y_trainV, epochs=1000, batch_size=100,verbose=0,validation_split=0.2)\n",
    "historyDB = modelDB.fit(X_trainB, y_trainB, epochs=1000, batch_size=100,verbose=0,validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(200, 42)\n",
      "(200, 42)\n"
     ]
    }
   ],
   "source": [
    "y_predDV=modelDV.predict(X_testV)\n",
    "y_predDB=modelDB.predict(X_testB)\n",
    "print(X_testB.shape)\n",
    "print(X_testV.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(882, 78)\n",
      "(882, 20)\n",
      "(882, 39)\n",
      "(882, 46)\n"
     ]
    }
   ],
   "source": [
    "#Final testing\n",
    "#dataset for final testing\n",
    "X_test_dem=X_dem[4000:,0:]\n",
    "y_test_gen =y_gen[4000:,0:]\n",
    "y_test_bus=y_bus[4000:,0:]\n",
    "y_test_branch=y_branch[4000:,0:]\n",
    "print(X_test_dem.shape)\n",
    "print(y_test_gen.shape)\n",
    "print(y_test_bus.shape)\n",
    "print(y_test_branch.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(882, 78)\n",
      "(882, 42)\n"
     ]
    }
   ],
   "source": [
    "#Filtering zeros from demand\n",
    "X_test_dem_temp=X_test_dem[:,load_index[0,0:]]\n",
    "\n",
    "print(X_test_dem.shape)\n",
    "print(X_test_dem_temp.shape)\n",
    "\n",
    "# Generation prediction \n",
    "y_predG=modelG.predict(X_test_dem_temp)\n",
    "\n",
    "#converting (ng*1) to (nb*1) matrix\n",
    "#As pyhton indexing start from zero\n",
    "Gen_index=Gen_index-1\n",
    "y_predG_temp=np.zeros([np.size(X_test_dem,0),nb*2], dtype = int)\n",
    "for s in range(np.size(X_test_dem,0)):\n",
    "    for i in range(ng):    \n",
    "        y_predG_temp[s,Gen_index[i]]=y_predG[s,i]\n",
    "        y_predG_temp[s,Gen_index[i]+nb]=y_predG[s,i+ng] \n",
    "           \n",
    "#forming net injection vectors\n",
    "X_NI_test=y_predG_temp-X_test_dem\n",
    "\n",
    "# bus and branch prediction \n",
    "y_predV=modelV.predict(X_NI_test)\n",
    "y_predB=modelB.predict(X_NI_test)\n",
    "\n",
    "y_predDV=modelDV.predict(X_test_dem_temp)\n",
    "y_predDB=modelDB.predict(X_test_dem_temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24086  5272]\n",
      " [   14  5026]]\n",
      "[[38807    25]\n",
      " [    1  1739]]\n"
     ]
    }
   ],
   "source": [
    "# testing the trained regressor\n",
    "\n",
    "#testing the trained voltage classifier\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "y_testV=np.reshape(y_test_bus,np.size(X_test_dem,0)*nb)\n",
    "y_predV=np.reshape(y_predV,np.size(X_test_dem,0)*nb)\n",
    "\n",
    "y_predV[y_predV >= 0.001] = 1\n",
    "y_predV[y_predV < 0.001] = 0\n",
    "\n",
    "print(confusion_matrix(y_testV, y_predV))\n",
    "\n",
    "#testing the trained branch classifier\n",
    "y_testB=np.reshape(y_test_branch,np.size(X_test_dem,0)*nl)\n",
    "y_predB=np.reshape(y_predB,np.size(X_test_dem,0)*nl)\n",
    "\n",
    "y_predB[y_predB >= 0.001] = 1\n",
    "y_predB[y_predB < 0.001] = 0\n",
    "\n",
    "print(confusion_matrix(y_testB, y_predB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24869  4489]\n",
      " [   16  5024]]\n",
      "[[38807    25]\n",
      " [    1  1739]]\n"
     ]
    }
   ],
   "source": [
    "# testing the DB trained regressor\n",
    "y_predDV=np.reshape(y_predDV,np.size(X_test_dem,0)*nb)\n",
    "\n",
    "y_predDV[y_predDV >= 0.001] = 1\n",
    "y_predDV[y_predDV < 0.001] = 0\n",
    "\n",
    "print(confusion_matrix(y_testV, y_predDV))\n",
    "\n",
    "#testing the trained branch classifier\n",
    "y_predDB=np.reshape(y_predDB,np.size(X_test_dem,0)*nl)\n",
    "\n",
    "y_predDB[y_predDB >= 0.001] = 1\n",
    "y_predDB[y_predDB < 0.001] = 0\n",
    "\n",
    "print(confusion_matrix(y_testB, y_predDB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}