SVM_FeatureVector.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "import cv2\n",
    "import imp\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "from alexnetG2 import AlexNet\n",
    "pd.set_option('display.max_rows', 500000)\n",
    "%matplotlib inline\n",
    "imagenet_mean = np.array([104., 117., 124.], dtype=np.float32)\n",
    "current_dir = os.getcwd()\n",
    "image_dir = os.path.join(current_dir, 'images')\n",
    "\n",
    "# Use SVM file path now instead of FilePathTable.csv\n",
    "CSV_FilePath = \"./svmtrain.csv\" # change this for TBT way\n",
    "num_classes = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class List\n",
    "- PathDetails (path)\n",
    "- ImgDetails  (path)\n",
    "- Seed_Classifier_St3\n",
    "- Analyse_PredictionResults"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PathDetails:\n",
    "    \n",
    "    def __init__ (self, Path):\n",
    "        self.PathDF = pd.read_table(Path, sep = ',')  # Converts the csv to DF format\n",
    "        \n",
    "    def Get_ImgPath_FilePath(self):\n",
    "        df = self.PathDF\n",
    "        fpath = './'+df.ImgListPath_Dir.head(1).values [0] +'/'+df.ImgListPath_File_Name.head(1).values [0]\n",
    "        return (fpath)\n",
    "        \n",
    "    def Get_ChkPoint_FilePath(self,i):\n",
    "        df = self.PathDF\n",
    "        fpath = './'+df.Checkpoint_Root_Dir.values [i] +'/' + df.Classifier_Root_Dir.values [i]\n",
    "        return (fpath)\n",
    "        \n",
    "    def Get_ChkPointModel_FilePath(self,i):\n",
    "        df = self.PathDF\n",
    "        fpath = './'+df.Checkpoint_Root_Dir.values [i] +'/' + df.Classifier_Root_Dir.values [i] +'/' + df.Classifier_Model_Path.values [i] \n",
    "        return (fpath)\n",
    "\n",
    "    def Get_CaffClassName_FilePath(self,i):\n",
    "        df = self.PathDF\n",
    "        fpath = './'+df.Checkpoint_Root_Dir.values [i] +'/' + df.Classifier_Root_Dir.values [i] +'/' + df.CaffeClassNames_File.values [i] \n",
    "        return (fpath)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImgDetails:\n",
    "    \n",
    "    def __init__ (self,Path):\n",
    "\n",
    "        img_path_list = []\n",
    "        imgs = []\n",
    "        lables = []\n",
    "\n",
    "        with open(Path, 'r') as img_files:\n",
    "            # Load all images\n",
    "            for i, f in enumerate (img_files):\n",
    "                img_path,lable = f.split(' ')\n",
    "                img_path_list.append(img_path)\n",
    "                imgs.append(cv2.imread(img_path))\n",
    "                lables.append(lable)\n",
    "        img_files.close\n",
    "        self.img_path_list = img_path_list\n",
    "        self.imgs = imgs\n",
    "        self.lables = lables      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seed_Classifier_St3:\n",
    "    \n",
    "    def __init__(self):\n",
    "\n",
    "        self.Initialization_Flag = False\n",
    "        \n",
    "    def Initialize_Dataframes(self, path):\n",
    "        \n",
    "        self.Path = path\n",
    "        self.Initialization_Flag = True\n",
    "        self.Load_DF()\n",
    "        self.Create_ActiveDF()\n",
    "        print (\"Successful: Initialize_Dataframes\")\n",
    "        \n",
    "    def Initialization_Check(self):\n",
    "        \n",
    "        if not(self.Initialization_Flag): \n",
    "            print (\"ERROR: Dataframe not initalised. Please run Initialise_Dataframes(<PATH>)\")\n",
    "            return 0\n",
    "        return 1\n",
    "       \n",
    "    def Load_DF (self):\n",
    "        \n",
    "        if not (self.Initialization_Check()): return \n",
    "        path=self.Path\n",
    "        self.Loaded_Data = pd.read_table(path, delim_whitespace=True, \n",
    "                             names=('Path',\n",
    "                                    'Set', \n",
    "                                    'Prediction', \n",
    "                                    'Probability',\n",
    "                                    'Expectation'),\n",
    "                             dtype={'Set': np.str, 'Prediction': np.float64, 'Probability': np.float64, 'Expectation': np.float64}) \n",
    "        self.Load_DF_Status=True\n",
    "        print (\"Successful: Load_DF\")\n",
    "        \n",
    "    def  Create_ActiveDF(self):\n",
    "        \n",
    "        # Get data\n",
    "        if not (self.Initialization_Check()): return \n",
    "        Loaded_Data=self.Loaded_Data\n",
    "        \n",
    "        # Setting Active_df\n",
    "        Active_df = pd.DataFrame(columns =['Path',\n",
    "                                    'Category',\n",
    "                                    'Img_Name',\n",
    "                                    'Set', \n",
    "                                    'ClassifierName',\n",
    "                                    'Prediction', \n",
    "                                    'Probability',\n",
    "                                    'Expectation'])\n",
    "        # Active_df +++>\n",
    "        # Path, Set, Prediction, Probability, Expectation\n",
    "        Active_df.Path=Loaded_Data.Path\n",
    "        Active_df.Set=Loaded_Data.Set\n",
    "        Active_df.Prediction=Loaded_Data.Prediction\n",
    "        Active_df.Probability=Loaded_Data.Probability\n",
    "        Active_df.Expectation=Loaded_Data.Expectation\n",
    "\n",
    "        # Category, Img_Name\n",
    "        t_path_stack = Loaded_Data.Path.str.split('/', expand=True).stack()\n",
    "        Active_df.Category = t_path_stack[:, 7]\n",
    "        Active_df.Img_Name = t_path_stack[:, 8]\n",
    "\n",
    "        # ClassifierName\n",
    "        Active_df.ClassifierName ='Classifier' + Loaded_Data.Set \n",
    "        self.Active_df = Active_df\n",
    "        print(\"Successful: Create_Active_DF\")\n",
    "        \n",
    "        \n",
    "    def Create_TProbabilityColLabels(self):\n",
    "        \n",
    "        if not (self.Initialization_Check()): return \n",
    "        # Create a Confusion matrix for an image\n",
    "        data = {'Prediction':[1,2,6,7],\n",
    "                'Classifier1312':np.zeros(4),\n",
    "                'Classifier2316':np.zeros(4),\n",
    "                'Classifier3317':np.zeros(4),\n",
    "                'Classifier4326':np.zeros(4),\n",
    "                'Classifier5327':np.zeros(4),\n",
    "                'Classifier6367':np.zeros(4),\n",
    "               }\n",
    "        print (\"Successful: Create_TProbabilityColLabels\")\n",
    "        return data  \n",
    "      \n",
    "    def Create_PredictionResultDfColLabels(self):\n",
    "        \n",
    "        if not (self.Initialization_Check()): return \n",
    "        # Create a result matrix for an image\n",
    "        data = {'Class1':np.zeros(1),\n",
    "                'Class2':np.zeros(1),\n",
    "                'Class6':np.zeros(1),\n",
    "                'Class7':np.zeros(1),\n",
    "                'Prediction':np.zeros(1),\n",
    "                'Probability':np.zeros(1),\n",
    "               }\n",
    "        print (\"Successful: Create_PredictionResultDfColLabels\")\n",
    "        return data \n",
    "    \n",
    "    def Get_TotalProbability(self, name):\n",
    "        \n",
    "        if not (self.Initialization_Check()): return \n",
    "        # Initialise\n",
    "        iname=name\n",
    "        df=self.Active_df\n",
    "\n",
    "        # Create a total probability matrix for an image\n",
    "        Lables = self.Create_TProbabilityColLabels()\n",
    "        Probability_Df = pd.DataFrame(Lables)\n",
    "\n",
    "        # Iteration over the rows of prediction for that image\n",
    "        Selected_Img_df=self.Search_Img(iname)\n",
    "        for index, Selected_Row in Selected_Img_df.iterrows():\n",
    "            Relative_Index =  Probability_Df.index[Probability_Df['Prediction'] == Selected_Row.Prediction]\n",
    "            Probability_Df.at[Relative_Index,Selected_Row.ClassifierName] =  Selected_Row.Probability\n",
    "        \n",
    "        # Obtain the mean from the probs. from the 6 classifiers\n",
    "        Probability_Df ['Total_Probability'] = Probability_Df.iloc[:, 1:8].mean(axis=1)\n",
    "        print (\"Successful: Get_TotalProbability\")\n",
    "        return Probability_Df\n",
    "  \n",
    "    def Get_PredictionResult(self, name):\n",
    "        \n",
    "        # Initialization check\n",
    "        if not (self.Initialization_Check()): return \n",
    "        \n",
    "        # Create a prediction result df for an image\n",
    "        Probability_Table=self.Get_TotalProbability(name)        \n",
    "        temp = Probability_Table.loc[Probability_Table['Total_Probability'].idxmax()]\n",
    "        Lables = self.Create_PredictionResultDfColLabels()\n",
    "        PredictionResult = pd.DataFrame(Lables)\n",
    "   \n",
    "        # Assign Probability\n",
    "        PredictionResult['Class1']=Probability_Table.iloc[Probability_Table.index[Probability_Table.Prediction==1] [0]]['Total_Probability']\n",
    "        PredictionResult['Class2']=Probability_Table.iloc[Probability_Table.index[Probability_Table.Prediction==2] [0]]['Total_Probability']\n",
    "        PredictionResult['Class6']=Probability_Table.iloc[Probability_Table.index[Probability_Table.Prediction==6] [0]]['Total_Probability']\n",
    "        PredictionResult['Class7']=Probability_Table.iloc[Probability_Table.index[Probability_Table.Prediction==7] [0]]['Total_Probability']\n",
    "        PredictionResult['Probability']=temp.Total_Probability\n",
    "        PredictionResult['Prediction']=temp.Prediction\n",
    "        print (\"Successful: Get_PredictionResult\")\n",
    "        return PredictionResult\n",
    "     \n",
    "    def Get_UniqueImgList(self):\n",
    "        \"\"\"Creates a list of names of images in the dataframe\"\"\"\n",
    "        \n",
    "        # Initialization check\n",
    "        if not (self.Initialization_Check()): return \n",
    "        \n",
    "        # Generate List\n",
    "        Active_df=self.Active_df\n",
    "        Img_Name_List= list (Active_df['Img_Name'].unique())\n",
    "        print (\"Successful: Get_UniqueImgList\")\n",
    "        return Img_Name_List\n",
    "              \n",
    "    def Search_Img(self,name):\n",
    "        \n",
    "        # Initialization check\n",
    "        if not (self.Initialization_Check()): return \n",
    "        \n",
    "        # Using Active_df\n",
    "        df = self.Active_df\n",
    "        Selected_Img_df = df[df.Img_Name==name]\n",
    "        if Selected_Img_df.empty: print('ERROR: DataFrame is empty! \\nSuggestion: Please check your image name.')\n",
    "        return Selected_Img_df\n",
    "        \n",
    "    def PrintToFile_Active_df(self,path):\n",
    "        \n",
    "        # Initialization check\n",
    "        if not (self.Initialization_Check()): return \n",
    "        \n",
    "        Active_df=self.Active_df\n",
    "        os.remove('./Path/Active_df.csv') if os.path.exists('./Path/Active_df.csv') else None\n",
    "        Active_df.to_csv(r'./Path/Active_df.csv', header=('Path',\n",
    "                                            'Category',\n",
    "                                            'Img_Name',\n",
    "                                            'Set', \n",
    "                                            'ClassifierName',\n",
    "                                            'Prediction', \n",
    "                                            'Probability',\n",
    "                                            'Expectation'), \n",
    "                                            index=None, sep=',', mode='a')\n",
    "        print (\"Successful: PrintToFile_Active_df\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Analyse_PredictionResults:    \n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        self.Initialization_Flag=False\n",
    "        self.Table=pd.DataFrame()\n",
    "    \n",
    "    def Extract_ImgInfo(self, ImgDetails, Prediction_Probability):\n",
    "        df = Prediction_Probability\n",
    "        df['Path'] = ImgDetails.Path.values [0]\n",
    "        df['Category'] = ImgDetails.Category.values [0]\n",
    "        df['Img_Name'] = ImgDetails.Img_Name.values [0]\n",
    "        df['Expectation'] = ImgDetails.Expectation.values [0]\n",
    "        df['Match'] = (df['Prediction'] == df['Expectation']) # Match check\n",
    "        return df\n",
    "    \n",
    "    def Append_ToTable(self,df):\n",
    "        self.Table = self.Table.append(df)\n",
    "        print (\"Successful: Append_ToTable\")\n",
    "        \n",
    "    def SaveTo_CSV(self):   \n",
    "        if (self.Table.size.size > 0): \n",
    "            self.Table.to_csv('./Result-FPSC3/St3_Prediction_Table.csv',sep = ' ')\n",
    "            print(\"Successful: Table was saved.\")\n",
    "        else:\n",
    "            print(\"ERROR: Table not save as the Table is empty.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>ImgListPath_Dir</th>\n",
       "      <th>ImgListPath_File_Name</th>\n",
       "      <th>Checkpoint_Root_Dir</th>\n",
       "      <th>Classifier_Root_Dir</th>\n",
       "      <th>Classifier_Model_Path</th>\n",
       "      <th>CaffeClassNames_File</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Path</td>\n",
       "      <td>svmtrain_all6classes.txt</td>\n",
       "      <td>Checkpoints</td>\n",
       "      <td>Checkpoint_1312</td>\n",
       "      <td>model_epoch500.ckpt.meta</td>\n",
       "      <td>caffe_classes_plamseed.py</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Path</td>\n",
       "      <td>svmtrain_all6classes.txt</td>\n",
       "      <td>Checkpoints</td>\n",
       "      <td>Checkpoint_2316</td>\n",
       "      <td>model_epoch500.ckpt.meta</td>\n",
       "      <td>caffe_classes_plamseed.py</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Path</td>\n",
       "      <td>svmtrain_all6classes.txt</td>\n",
       "      <td>Checkpoints</td>\n",
       "      <td>Checkpoint_3317</td>\n",
       "      <td>model_epoch500.ckpt.meta</td>\n",
       "      <td>caffe_classes_plamseed.py</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Path</td>\n",
       "      <td>svmtrain_all6classes.txt</td>\n",
       "      <td>Checkpoints</td>\n",
       "      <td>Checkpoint_4326</td>\n",
       "      <td>model_epoch500.ckpt.meta</td>\n",
       "      <td>caffe_classes_plamseed.py</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Path</td>\n",
       "      <td>svmtrain_all6classes.txt</td>\n",
       "      <td>Checkpoints</td>\n",
       "      <td>Checkpoint_5327</td>\n",
       "      <td>model_epoch500.ckpt.meta</td>\n",
       "      <td>caffe_classes_plamseed.py</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Path</td>\n",
       "      <td>svmtrain_all6classes.txt</td>\n",
       "      <td>Checkpoints</td>\n",
       "      <td>Checkpoint_6367</td>\n",
       "      <td>model_epoch500.ckpt.meta</td>\n",
       "      <td>caffe_classes_plamseed.py</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  ImgListPath_Dir     ImgListPath_File_Name Checkpoint_Root_Dir  \\\n",
       "0            Path  svmtrain_all6classes.txt         Checkpoints   \n",
       "1            Path  svmtrain_all6classes.txt         Checkpoints   \n",
       "2            Path  svmtrain_all6classes.txt         Checkpoints   \n",
       "3            Path  svmtrain_all6classes.txt         Checkpoints   \n",
       "4            Path  svmtrain_all6classes.txt         Checkpoints   \n",
       "5            Path  svmtrain_all6classes.txt         Checkpoints   \n",
       "\n",
       "  Classifier_Root_Dir     Classifier_Model_Path       CaffeClassNames_File  \n",
       "0     Checkpoint_1312  model_epoch500.ckpt.meta  caffe_classes_plamseed.py  \n",
       "1     Checkpoint_2316  model_epoch500.ckpt.meta  caffe_classes_plamseed.py  \n",
       "2     Checkpoint_3317  model_epoch500.ckpt.meta  caffe_classes_plamseed.py  \n",
       "3     Checkpoint_4326  model_epoch500.ckpt.meta  caffe_classes_plamseed.py  \n",
       "4     Checkpoint_5327  model_epoch500.ckpt.meta  caffe_classes_plamseed.py  \n",
       "5     Checkpoint_6367  model_epoch500.ckpt.meta  caffe_classes_plamseed.py  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PathDB = PathDetails(CSV_FilePath) # Separates the contents of the csv. accordingly\n",
    "ImgList_FilePath = PathDB.Get_ImgPath_FilePath() # Gets the image file path\n",
    "ImgDB = ImgDetails(ImgList_FilePath) # Loads the images into array from the given path\n",
    "PathDB.PathDF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration\n",
    "Running iterative loop on each of the binary classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./Checkpoints/Checkpoint_1312/model_epoch500.ckpt\n",
      "./Checkpoints/Checkpoint_1312\n",
      "INFO:tensorflow:Restoring parameters from ./Checkpoints/Checkpoint_1312/model_epoch500.ckpt\n",
      "Loading checkpoint =  0\n",
      "Loading Pretrained weight.\n",
      "./Checkpoints/Checkpoint_2316\n",
      "INFO:tensorflow:Restoring parameters from ./Checkpoints/Checkpoint_2316/model_epoch500.ckpt\n",
      "Loading checkpoint =  1\n",
      "Loading Pretrained weight.\n",
      "./Checkpoints/Checkpoint_3317\n",
      "INFO:tensorflow:Restoring parameters from ./Checkpoints/Checkpoint_3317/model_epoch500.ckpt\n",
      "Loading checkpoint =  2\n",
      "Loading Pretrained weight.\n",
      "./Checkpoints/Checkpoint_4326\n",
      "INFO:tensorflow:Restoring parameters from ./Checkpoints/Checkpoint_4326/model_epoch500.ckpt\n",
      "Loading checkpoint =  3\n",
      "Loading Pretrained weight.\n",
      "./Checkpoints/Checkpoint_5327\n",
      "INFO:tensorflow:Restoring parameters from ./Checkpoints/Checkpoint_5327/model_epoch500.ckpt\n",
      "Loading checkpoint =  4\n",
      "Loading Pretrained weight.\n",
      "./Checkpoints/Checkpoint_6367\n",
      "INFO:tensorflow:Restoring parameters from ./Checkpoints/Checkpoint_6367/model_epoch500.ckpt\n",
      "Loading checkpoint =  5\n",
      "Loading Pretrained weight.\n",
      "Images and Labels loaded for checkpoint =  5\n",
      "CPU times: user 9min 55s, sys: 10min 39s, total: 20min 34s\n",
      "Wall time: 24min 38s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Placeholder for input and dropout rate, x is the input image\n",
    "x = tf.placeholder(tf.float32, [1, 227, 227, 3])\n",
    "keep_prob = tf.placeholder(tf.float32)\n",
    "\n",
    "# Copy all images\n",
    "ImageArray = ImgDB.imgs\n",
    "\n",
    "# Set result Directory\n",
    "rfname = './Result-FPSC3/St_Output_Linux.csv'\n",
    "os.remove(rfname) if os.path.exists(rfname) else None\n",
    "\n",
    "i = 0\n",
    "Model_Path = PathDB.Get_ChkPointModel_FilePath(i)\n",
    "CheckpointDir_Path = PathDB.Get_ChkPoint_FilePath(i)\n",
    "sess = tf.InteractiveSession()\n",
    "saver = tf.train.import_meta_graph(Model_Path)\n",
    "saver.restore(sess,tf.train.latest_checkpoint(CheckpointDir_Path))\n",
    "saved_dict = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)\n",
    "\n",
    "model = AlexNet(x, keep_prob, num_classes, [], saved_dict, load_pretrained_weight = True)\n",
    "\n",
    "# Loop for each checkpoint\n",
    "for i in range(0, 6): \n",
    "    \n",
    "    # Setting variable values\n",
    "    original_class_lable = ''\n",
    "    Model_Path = PathDB.Get_ChkPointModel_FilePath(i)\n",
    "    CheckpointDir_Path = PathDB.Get_ChkPoint_FilePath(i)\n",
    "    ClassFile_Path = PathDB.Get_CaffClassName_FilePath(i)\n",
    "    print(CheckpointDir_Path)\n",
    "    \n",
    "    ClassNameModule = imp.load_source('class_names', ClassFile_Path)\n",
    "    class_names = ClassNameModule.class_names\n",
    "    saver = tf.train.import_meta_graph(Model_Path)\n",
    "    saver.restore(sess,tf.train.latest_checkpoint(CheckpointDir_Path))\n",
    "    saved_dict = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)\n",
    "    print('Loading checkpoint = ', i)\n",
    "    \n",
    "    # Load the pretrained weights into the model\n",
    "    model.load_initial_weights(sess)\n",
    "    score = model.fc8\n",
    "    prescore = model.fc7\n",
    "\n",
    "    # Create op to calculate softmax \n",
    "    # softmax = tf.nn.softmax(score)\n",
    "\n",
    "    images = ImgDB.imgs\n",
    "    labels = ImgDB.lables\n",
    "    imagefeatures = []\n",
    "    labelfeatures = []\n",
    "    scorefeatures = []\n",
    "    \n",
    "    # Loop over all images\n",
    "    for j, image in enumerate(images):\n",
    "        \n",
    "        img = cv2.resize(image.astype(np.float32), (227,227))\n",
    "        img = img - imagenet_mean\n",
    "        img = img.reshape((1, 227, 227, 3))\n",
    "        \n",
    "        # Activation maps output\n",
    "        layer7Vector = sess.run(prescore, feed_dict={x: img, keep_prob: 1})\n",
    "        layer8Vector = sess.run(softmax, feed_dict={x: img, keep_prob: 1})\n",
    "        \n",
    "        # Obtain feature of the individual image\n",
    "        imagefeatures.append(layer7Vector) \n",
    "        scorefeatures.append(layer8vector)\n",
    "        \n",
    "    # Loop over all the labels \n",
    "    for a, label in enumerate(labels):\n",
    "    \n",
    "        labelfeatures.append(labels)\n",
    "'''\n",
    "        # Run the session and calculate the class probability\n",
    "        probs = sess.run(softmax, feed_dict = {x: img, keep_prob: 1})\n",
    "\n",
    "        # Get the class name of the class with the highest probability\n",
    "        class_name = class_names[np.argmax(probs)]\n",
    "\n",
    "        # Lables converted to the respective labels of the classes\n",
    "        original_class_lable = class_name[5]\n",
    "    \n",
    "        # Filename to write\n",
    "        with open(rfname, 'a') as myfile:\n",
    "            ptr = myfile.write(ImgDB.img_path_list[j]+\" \"+CheckpointDir_Path[-4:]+\" \"+class_name[5]+\" \" +\"%.4f\" %probs[0,np.argmax(probs)]+' '+ImgDB.lables[j]) \n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "# Initilize Dataframe\n",
    "# Parameter: none\n",
    "newresult = './finalpath_rabbi.csv'\n",
    "myDF = Seed_Classifier_St3()\n",
    "_ = myDF.Initialize_Dataframes(newresult)\n",
    "\n",
    "# List of images \n",
    "# Parameter: myDF\n",
    "myImg_Name_List = myDF.Get_UniqueImgList()\n",
    "\n",
    "# Creating a DF to analyse the result\n",
    "Analyse_ResultDF=Analyse_PredictionResults()\n",
    "\n",
    "for iname in myImg_Name_List:\n",
    "    \n",
    "    # Get the max probability for prediction\n",
    "    PredictionResult_DF = myDF.Get_PredictionResult(iname)\n",
    "\n",
    "    # Get current image details\n",
    "    ImageDetails_DF = myDF.Search_Img(iname)\n",
    "    \n",
    "    # Converting the dataframe into a suitable format\n",
    "    # so that it can be added as row\n",
    "    Row = Analyse_ResultDF.Extract_ImgInfo(ImageDetails_DF,PredictionResult_DF)\n",
    "    _ = Analyse_ResultDF.Append_ToTable(Row)\n",
    "    \n",
    "# Save result\n",
    "_ = Analyse_ResultDF.SaveTo_CSV()\n",
    "#Analyse_ResultDF.Table\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "raw_mimetype": "text/markdown"
   },
   "source": [
    "## Flatten the feature mapping\n",
    "\n",
    "flatimagefeatures contains all the features of all the training images of total size (371,4096) where 371 is the total number of training images and 4096 is the feature maps of each image. To input to SVM, squeeze() is use to change it a 1D vector. Same is done to the labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(371,)"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(371, 4096)"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Flatten into 1D vector\n",
    "\n",
    "flatimagefeatures = np.squeeze(imagefeatures)\n",
    "flatlabelfeatures = np.array(labelfeatures, dtype = int) \n",
    "flatlabelfeatures = ((flatlabelfeatures[0:1]).T).ravel() \n",
    "flatlabelfeatures = flatlabelfeatures.ravel()\n",
    "flatlabelfeatures.shape\n",
    "flatimagefeatures.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save feature vector if needed\n",
    "\n",
    "np.savetxt(\"featuresReLu.csv\", flatimagefeatures, delimiter=\",\", fmt='%.3e')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'flatimagefeatures' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<timed exec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'flatimagefeatures' is not defined"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Training the linear SVM using SVC\n",
    "import sklearn\n",
    "import sklearn.svm\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.svm import LinearSVC\n",
    "\n",
    "modelSVM = LinearSVC(random_state=0, loss='hinge')\n",
    "modelSVM.fit(flatimagefeatures, flatlabelfeatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing images and labels for SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'PathDetails' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-ee3ff5aa6523>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mCSV_FilePath_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"./testingSVM.csv\"\u001b[0m \u001b[0;31m# Test file path\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mPathDB_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPathDetails\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mCSV_FilePath_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mImgList_FilePath_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPathDB_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGet_ImgPath_FilePath\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mImgDB_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImgDetails\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mImgList_FilePath_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'PathDetails' is not defined"
     ]
    }
   ],
   "source": [
    "# Predict the class of a new image using our trained model\n",
    "\n",
    "CSV_FilePath_test = \"./testingSVM.csv\" # Test file path\n",
    "PathDB_test = PathDetails(CSV_FilePath_test)\n",
    "ImgList_FilePath_test = PathDB_test.Get_ImgPath_FilePath()\n",
    "ImgDB_test = ImgDetails(ImgList_FilePath_test)\n",
    "\n",
    "imagefeaturesTest = []\n",
    "labelfeaturesTest = []\n",
    "\n",
    "# Train all image, then test with something else\n",
    "\n",
    "for jTest, imageTest in enumerate(ImgDB_test.imgs):\n",
    "\n",
    "    img = cv2.resize(imageTest.astype(np.float32), (227,227))   \n",
    "    img = img - imagenet_mean\n",
    "    img = img.reshape((1, 227, 227, 3))\n",
    "    img = np.array(img).astype(np.float32)\n",
    "    layer7VectorTest = sess.run(prescore, feed_dict={x: img, keep_prob: 1}) # Obtain feature of the individual image\n",
    "    imagefeaturesTest.append(layer7VectorTest)# append all the features\n",
    "    \n",
    "for aTest, labelTest in enumerate(ImgDB_test.lables):\n",
    "    \n",
    "    labelfeaturesTest.append(ImgDB_test.lables)\n",
    "    \n",
    "# Flatten into 1D vector\n",
    "\n",
    "flatimagefeaturesTest = np.squeeze(imagefeaturesTest)  \n",
    "flatlabelfeaturesTest = np.array(labelfeaturesTest, dtype = int)\n",
    "flatlabelfeaturesTest = (flatlabelfeaturesTest[0:1]).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the predictions with the test set for SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create prediction with the test set\n",
    "\n",
    "predicted_class_testarray = []\n",
    "\n",
    "for i in range(len(flatlabelfeaturesTest)):\n",
    "    f2test = flatimagefeaturesTest[i, :] # Getting the test image features up to 370 image and predicting\n",
    "    predicted_class_test = modelSVM.predict([f2test]) # Prediction of the image using the features learned\n",
    "    predicted_class_testarray.append(predicted_class_test)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting function for confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "def plot_confusion_matrix(cm, target_names, title = 'Confusion Matrix', cmap = None, normalize = True):\n",
    "    \n",
    "    accuracy = np.trace(cm) / float(np.sum(cm))\n",
    "    misclass = 1 - accuracy\n",
    "\n",
    "    if cmap is None:\n",
    "        cmap = plt.get_cmap('Blues')\n",
    "\n",
    "    plt.figure(figsize = (7, 7))\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "\n",
    "    if target_names is not None:\n",
    "        target_names = ['Class 1', 'Class 2', 'Class 6', 'Class 7'] # Use string names\n",
    "        tick_marks = np.arange(len(target_names))\n",
    "        plt.xticks(tick_marks, target_names, rotation=0)\n",
    "        plt.yticks(tick_marks, target_names)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "    thresh = cm.max() / 1.5 if normalize else cm.max() / 2\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        if normalize:\n",
    "            plt.text(j, i, \"{:0.3f}\".format(cm[i, j]),horizontalalignment=\"center\",color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "        else:\n",
    "            plt.text(j, i, \"{:,}\".format(cm[i, j]),horizontalalignment=\"center\",color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.ylabel('REAL')\n",
    "    plt.xlabel('PREDICTED\\n Accuracy = {:0.3f} || Error = {:0.3f}'.format(accuracy, misclass))\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-9159f3eb72db>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Checking the prediction against real ones\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mPredSVM\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpredicted_class_testarray\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mTrueSVM\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflatlabelfeaturesTest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mcm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconfusion_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflatlabelfeaturesTest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpredicted_class_testarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 4 classes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "# Checking the prediction against real ones\n",
    "\n",
    "PredSVM = (np.array(predicted_class_testarray)).ravel()\n",
    "TrueSVM = flatlabelfeaturesTest.ravel()\n",
    "cm = confusion_matrix(flatlabelfeaturesTest.ravel(), predicted_class_testarray, labels = [1, 2, 6, 7]) # 4 classes\n",
    "plot_confusion_matrix(cm, [1, 2, 6, 7], normalize=False) # Normalize to get probs. \n",
    "print('SVM Accuracy =', np.mean(PredSVM == TrueSVM) * 100.0)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}