Part2_Hybrid Learning Aided Inactive Constraints Filtering Algorithm to Enhance AC OPF Solution Time.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1354\n",
      "1991\n",
      "260\n"
     ]
    }
   ],
   "source": [
    "#dataset import for regressor\n",
    "X_dem=pd.read_excel(r'C:\\Users\\fhasan1\\Dataset1354.xlsx', header=None, sheet_name=0)#demand data\n",
    "y_gen=pd.read_excel(r'C:\\Users\\fhasan1\\Dataset1354.xlsx', header=None, sheet_name=1)#generation data\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\\Dataset1354.xlsx', header=None, sheet_name=2)#outputbus\n",
    "y_branch=pd.read_excel(r'C:\\Users\\fhasan1\\Dataset1354.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\\Dataset1354.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\\Dataset1354.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": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4200, 2708)\n",
      "(4200, 520)\n",
      "(4200, 1354)\n",
      "(4200, 1991)\n",
      "(260, 1)\n",
      "(1, 1332)\n"
     ]
    }
   ],
   "source": [
    "X_dem = np.array(X_dem, dtype=\"float32\")\n",
    "y_gen = np.array(y_gen, dtype=\"float32\")\n",
    "y_bus = np.array(y_bus, dtype=\"float32\")\n",
    "y_branch = np.array(y_branch, dtype=\"float32\")\n",
    "\n",
    "#verifying the size of datasets\n",
    "print(X_dem.shape)\n",
    "print(y_gen.shape)\n",
    "print(y_bus.shape)\n",
    "print(y_branch.shape)\n",
    "print(Gen_index.shape)\n",
    "print(load_index.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1500, 2708)\n",
      "(1500, 520)\n"
     ]
    }
   ],
   "source": [
    "#dataset for regressor training\n",
    "X_regressor=X_dem[0:1500,0:]\n",
    "y_regressor=y_gen[0:1500,0:]\n",
    "print(X_regressor.shape)\n",
    "print(y_regressor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1500, 1332)\n"
     ]
    }
   ],
   "source": [
    "#Filtering zeros from demand\n",
    "X_regressor=X_regressor[:,load_index[0,0:]]           \n",
    "print(X_regressor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "xscaler = MinMaxScaler()\n",
    "yscaler = MinMaxScaler()\n",
    "#scaling\n",
    "X_regressor=xscaler.fit_transform(X_regressor)\n",
    "y_regressor=yscaler.fit_transform(y_regressor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Train test split of model\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_trainG,X_testG,y_trainG,y_testG = train_test_split(X_regressor,y_regressor,test_size = 0.001,random_state = 1,shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "modelG = Sequential()\n",
    "modelG.add(Dense(256, input_dim=np.size(X_regressor,1), activation='relu'))\n",
    "modelG.add(Dense(ng*2, activation='linear'))\n",
    "\n",
    "modelG.compile(loss='mse', optimizer='adam', metrics=['mse'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "custom_early_stopping = EarlyStopping(\n",
    "    monitor='val_loss', \n",
    "    patience=100, \n",
    "    min_delta=0.001, \n",
    "    mode='min',\n",
    "    verbose=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 00167: early stopping\n"
     ]
    }
   ],
   "source": [
    "historyG = modelG.fit(X_trainG, y_trainG, epochs=500, batch_size=100,verbose=0,validation_split=0.2,\n",
    "                      callbacks=[custom_early_stopping])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'mse', 'val_loss', 'val_mse'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(historyG.history.keys())\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(historyG.history['loss'])\n",
    "plt.plot(historyG.history['val_loss'])\n",
    "plt.title('Rgression learners loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation'], loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1500, 2708)\n",
      "(1500, 1354)\n",
      "(1500, 1991)\n"
     ]
    }
   ],
   "source": [
    "#dataset for classifier trainig\n",
    "X_classifier=X_dem[1500:3000,0:]\n",
    "y_classifier_bus=y_bus[1500:3000,0:]\n",
    "y_classifier_branch=y_branch[1500:3000,0:]\n",
    "print(X_classifier.shape)\n",
    "print(y_classifier_bus.shape)\n",
    "print(y_classifier_branch.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1500, 2708)\n",
      "(1500, 1332)\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",
    "X_classifier_dem=xscaler.transform(X_classifier_dem)# scaling demand\n",
    "y_predG=modelG.predict(X_classifier_dem)\n",
    "y_predG=yscaler.inverse_transform(y_predG)# descaling gen output\n",
    "X_classifier_dem=xscaler.inverse_transform(X_classifier_dem)# descaling demand\n",
    "\n",
    "print(X_classifier.shape)\n",
    "print(X_classifier_dem.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#converting (ng*1) to (nb*1) matrix\n",
    "#As pyhton indexing start from zero\n",
    "Gen_index=Gen_index-1\n",
    "\n",
    "y_predG_temp=np.zeros([np.size(X_classifier,0),nb*2], dtype = int)\n",
    "\n",
    "for s in range(np.size(X_classifier,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] #ng=10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1500, 2708)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#forming net injection vectors\n",
    "X_NI=y_predG_temp-X_classifier\n",
    "#scaling net injection vectors\n",
    "NIscaler = MinMaxScaler()\n",
    "X_NI=NIscaler.fit_transform(X_NI)\n",
    "\n",
    "X_NI.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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_NI,y_classifier_bus,test_size = 0.001,random_state = 0,shuffle=True)\n",
    "# model for branch\n",
    "X_trainB,X_testB,y_trainB,y_testB = train_test_split(X_NI,y_classifier_branch,test_size = 0.001,random_state = 0,shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow.keras.backend as K\n",
    "\n",
    "def f2(y_true, y_pred):\n",
    "    y_pred = K.round(y_pred)\n",
    "    tp = K.sum(K.cast(y_true*y_pred, 'float'), axis=0)\n",
    "    tn = K.sum(K.cast((1-y_true)*(1-y_pred), 'float'), axis=0)\n",
    "    fp = K.sum(K.cast((1-y_true)*y_pred, 'float'), axis=0)\n",
    "    fn = K.sum(K.cast(y_true*(1-y_pred), 'float'), axis=0)\n",
    "    p = tp / (tp + fp + K.epsilon())\n",
    "    r = tp / (tp + fn + K.epsilon())\n",
    "    f2 = 5*p*r / (4*p+r+K.epsilon())\n",
    "    return K.mean(f2)\n",
    "\n",
    "def f2_loss(y_true, y_pred):\n",
    "    \n",
    "    tp = K.sum(K.cast(y_true*y_pred, 'float'), axis=0)\n",
    "    tn = K.sum(K.cast((1-y_true)*(1-y_pred), 'float'), axis=0)\n",
    "    fp = K.sum(K.cast((1-y_true)*y_pred, 'float'), axis=0)\n",
    "    fn = K.sum(K.cast(y_true*(1-y_pred), 'float'), axis=0)\n",
    "    p = tp / (tp + fp + K.epsilon())\n",
    "    r = tp / (tp + fn + K.epsilon())\n",
    "    f2 = 5*p*r / (4*p+r+K.epsilon())\n",
    "    return 1 - K.mean(f2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "custom_early_stopping = EarlyStopping(\n",
    "    monitor='val_loss', \n",
    "    patience=100, \n",
    "    min_delta=0.00001, \n",
    "    mode='min',\n",
    "    verbose=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#bus slassifier model\n",
    "modelV = Sequential()\n",
    "modelV.add(Dense(256, input_dim=np.size(X_NI,1), activation='relu'))\n",
    "modelV.add(Dense(nb, activation='sigmoid'))\n",
    "modelV.compile(loss=f2_loss, optimizer='adam', metrics=[f2])\n",
    "\n",
    "#branch slassifier model\n",
    "modelB = Sequential()\n",
    "modelB.add(Dense(256, input_dim=np.size(X_NI,1), activation='relu'))\n",
    "modelB.add(Dense(nl, activation='sigmoid'))\n",
    "modelB.compile(loss=f2_loss, optimizer='adam', metrics=[f2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 00102: early stopping\n",
      "Epoch 00101: early stopping\n"
     ]
    }
   ],
   "source": [
    "historyV = modelV.fit(X_trainV, y_trainV, epochs=1000, batch_size=100,verbose=0,validation_split=0.2,callbacks=[custom_early_stopping])\n",
    "historyB = modelB.fit(X_trainB, y_trainB, epochs=1000, batch_size=100,verbose=0,validation_split=0.2,callbacks=[custom_early_stopping])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'f2', 'val_loss', 'val_f2'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(historyV.history.keys())\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(historyB.history['loss'])\n",
    "plt.plot(historyB.history['val_loss'])\n",
    "#plt.plot(historyB.history['accuracy'])\n",
    "plt.title('Voltage classification loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation', 'accuracy'], loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'f2', 'val_loss', 'val_f2'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(historyB.history.keys())\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(historyB.history['loss'])\n",
    "plt.plot(historyB.history['val_loss'])\n",
    "#plt.plot(historyB.history['accuracy'])\n",
    "plt.title('Branch classification loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation', 'accuracy'], loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1200, 2708)\n",
      "(1200, 520)\n",
      "(1200, 1354)\n",
      "(1200, 1991)\n"
     ]
    }
   ],
   "source": [
    "#Final testing\n",
    "X_test_dem=X_dem[3000:,0:]\n",
    "y_test_gen =y_gen[3000:,0:]\n",
    "y_test_bus=y_bus[3000:,0:]\n",
    "y_test_branch=y_branch[3000:,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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1200, 2708)\n",
      "(1200, 1332)\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",
    "X_test_dem_temp=xscaler.transform(X_test_dem_temp)#scaling demand\n",
    "y_predG=modelG.predict(X_test_dem_temp)\n",
    "y_predG=yscaler.inverse_transform(y_predG)#descaling gen output\n",
    "X_test_dem_temp=xscaler.inverse_transform(X_test_dem_temp)#descaling demand\n",
    "\n",
    "#converting (ng*1) to (nb*1) matrix\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",
    "X_NI_test=NIscaler.fit_transform(X_NI_test)#scaling net injection\n",
    "\n",
    "# bus and branch prediction \n",
    "y_predV=modelV.predict(X_NI_test)\n",
    "y_predB=modelB.predict(X_NI_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.323976871238045\n"
     ]
    }
   ],
   "source": [
    "# testing the trained regressor\n",
    "import math\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "RMSE=[]\n",
    "for x in range(np.size(X_test_dem,0)): \n",
    "    MSE=mean_squared_error(y_test_gen[x,:], y_predG[x,:])\n",
    "    RMSE.append(math.sqrt(MSE))\n",
    "    \n",
    "mean_RMSE=sum(RMSE)/len(RMSE)\n",
    "print(mean_RMSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1557549   39280]\n",
      " [    588   27383]]\n",
      "0.00018094534711964548 0.0120876415558838 0.9793048375184638 0.008426575578532743 0.9998152649581189 0.410767592217572 0.9789782274498587 0.9878074104746387 0.9877314130969965\n"
     ]
    }
   ],
   "source": [
    "#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_predV1=np.copy(y_predV)\n",
    "\n",
    "y_predV1[y_predV1 >= 0.99] = 1\n",
    "y_predV1[y_predV1 < 0.99] = 0\n",
    "\n",
    "CM=confusion_matrix(y_testV, y_predV1)\n",
    "\n",
    "TN = CM[0][0]\n",
    "FN = CM[1][0]\n",
    "TP = CM[1][1]\n",
    "FP = CM[0][1]\n",
    "\n",
    "s=np.size(X_test_dem,0)# no of test scenario\n",
    "c=s*nb*2 #total constraints is double for upper and lower limit\n",
    "TN=c-(TP+FP+FN)\n",
    "CM[0][0]=TN\n",
    "print(CM)\n",
    "\n",
    "FNP=(FN)/(TP+TN+FP+FN)\n",
    "FPP=(FP)/(TP+TN+FP+FN)\n",
    "TNP=(TN)/(TP+TN+FP+FN)\n",
    "TPP=(TP)/(TP+TN+FP+FN)\n",
    "\n",
    "NPV = TN/(TN+FN)\n",
    "PPV = TP/(TP+FP)# Precision\n",
    "TPR = TP/(TP+FN)# Sensitivity, recall \n",
    "TNR = TN/(TN+FP)# Specificity \n",
    "\n",
    "ACC = (TP+TN)/(TP+FP+FN+TN)\n",
    "\n",
    "print(FNP, FPP, TNP, TPP, NPV, PPV, TPR, TNR, ACC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2271862  100024]\n",
      " [      0   17314]]\n",
      "0.0 0.030780403741999016 0.963891555883801 0.005328040374199901 1.0 0.1475566312703472 1.0 0.9690547185490392 0.969219596258001\n"
     ]
    }
   ],
   "source": [
    "#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_predB1=np.copy(y_predB)\n",
    "\n",
    "y_predB1[y_predB1 >= 0.99] = 1\n",
    "y_predB1[y_predB1 < 0.99] = 0\n",
    "\n",
    "CM=confusion_matrix(y_testB, y_predB1)\n",
    "\n",
    "TN = CM[0][0]\n",
    "FN = CM[1][0]\n",
    "TP = CM[1][1]\n",
    "FP = CM[0][1]\n",
    "\n",
    "c=s*nb*2 \n",
    "TN=c-(TP+FP+FN)\n",
    "CM[0][0]=TN\n",
    "print(CM)\n",
    "\n",
    "FNP=(FN)/(TP+TN+FP+FN)\n",
    "FPP=(FP)/(TP+TN+FP+FN)\n",
    "TNP=(TN)/(TP+TN+FP+FN)\n",
    "TPP=(TP)/(TP+TN+FP+FN)\n",
    "\n",
    "NPV = TN/(TN+FN)\n",
    "PPV = TP/(TP+FP)\n",
    "TPR = TP/(TP+FN)\n",
    "TNR = TN/(TN+FP) \n",
    "\n",
    "ACC = (TP+TN)/(TP+FP+FN+TN)\n",
    "\n",
    "print(FNP, FPP, TNP, TPP, NPV, PPV, TPR, TNR, ACC)"
   ]
  },
  {
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}