classifyWith_LBP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.feature import hog\n",
    "from skimage import io,color\n",
    "from skimage.transform import resize\n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.ensemble import RandomForestClassifier,AdaBoostClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn import metrics\n",
    "import os\n",
    "from  LBP_descriptor import LocalBinaryPatterns\n",
    "import commonfunctions as cf\n",
    "import cv2\n",
    "import pandas as pd\n",
    "import csv\n",
    "from skimage.feature import greycomatrix, greycoprops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get our training data \n",
    "X_train: features of training data.\\\n",
    "Y_train: labels of training data (1-->F, 0--> M).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# ICDAR LABELS \n",
    "labels_ICDAR=[]\n",
    "with open(\"our dataset/train_answers.csv\", 'r') as file:\n",
    "    csvreader = csv.reader(file, delimiter=',')\n",
    "    rows= np.array(list(csvreader))[1:].astype(float).astype(int)\n",
    "for row in rows:\n",
    "    labels_ICDAR.append(row[1])\n",
    "    \n",
    "def get_label_ICDAR(img):\n",
    "    if img[0]=='0':\n",
    "        if img[1]=='0': \n",
    "            return labels_ICDAR[int(img[2])-1]\n",
    "        else: \n",
    "            return labels_ICDAR[int(img[1:3])-1]\n",
    "    else: \n",
    "         return labels_ICDAR[int(img[0:3])-1]\n",
    "        \n",
    "\n",
    "\n",
    "def read_labels(path): \n",
    "    y=[]\n",
    "    files = os.listdir(path)\n",
    "\n",
    "    for file in files:\n",
    "        if file[0]=='F':\n",
    "            y.append(0)\n",
    "        elif file[0]=='M':\n",
    "            y.append(1)\n",
    "        else: \n",
    "            y.append(get_label_ICDAR(file[1:4]))\n",
    "          \n",
    "    y=np.array(y).astype(float)\n",
    "    return y \n",
    "\n",
    "Y_train= read_labels(\"Training_data/\")\n",
    "Y_test= read_labels(\"Test_data/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LBP feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create object from LBP class to use it as our descriptor\n",
    "# takes 2 parameters: number of data (train + test ) and number of neighbors\n",
    "desc = LocalBinaryPatterns(24, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TRY LBP ONLY\n",
    "X_train=[]\n",
    " \n",
    "files = os.listdir(\"Training_data/\")\n",
    "for file in files:\n",
    "    # read the image\n",
    "    img = io.imread(\"Training_data/\"+file )\n",
    "\n",
    "    #------------------- LBP feature------------------------\n",
    "    img = cf.downSize(img , 0.5)\n",
    "    hist = desc.describe(img)\n",
    "    X_train.append(hist)\n",
    "    \n",
    "    #--------------------------------------------------------\n",
    "#convert to numpy array\n",
    "X_train=np.array(X_train)\n",
    "#write feature vector of test data in external file\n",
    "with open('LBP_train.npy', 'wb') as f:\n",
    "    np.save(f, X_train)\n",
    "f.close() \n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read feature vector of train data from the npy file \n",
    "with open('LBP_train.npy', 'rb') as f:\n",
    "    X_train = np.load(f,allow_pickle=True)\n",
    "f.close() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TEST LBP\n",
    "X_test=[]\n",
    "files = os.listdir(\"Test_data/\")\n",
    "\n",
    "for file in files:\n",
    "   \n",
    "    # read te img\n",
    "    img = io.imread(\"Test_data/\" +file )\n",
    "        \n",
    "    #------------------- LBP feature------------------------\n",
    "    img = cf.downSize(img , 0.5)\n",
    "    hist = desc.describe(img)\n",
    "    X_test.append(hist)  \n",
    "    \n",
    "X_test=np.array(X_test)\n",
    "#write feature vector of test data in external file\n",
    "with open('LBP_TEST.npy', 'wb') as f:\n",
    "    np.save(f, X_test)\n",
    "f.close() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classification:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Random forest classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 60.69364161849711 %\n"
     ]
    }
   ],
   "source": [
    "\n",
    "clf=RandomForestClassifier(n_estimators=2000)\n",
    "clf.fit(X_train,Y_train)\n",
    "Y_Predicted=clf.predict(X_test)\n",
    "print(\"Accuracy:\",metrics.accuracy_score(Y_test, Y_Predicted)*100,\"%\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Linear SVM classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 61.849710982658955 %\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\dell\\anaconda3\\lib\\site-packages\\sklearn\\svm\\_base.py:985: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
      "  warnings.warn(\"Liblinear failed to converge, increase \"\n"
     ]
    }
   ],
   "source": [
    "clf=LinearSVC(C=300.0, random_state=42)\n",
    "clf.fit(X_train,Y_train )\n",
    "Y_Predicted=clf.predict(X_test)\n",
    "print(\"Accuracy:\",metrics.accuracy_score(Y_test, Y_Predicted)*100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Adaboost classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 53.179190751445084 %\n"
     ]
    }
   ],
   "source": [
    "clf=AdaBoostClassifier(n_estimators=3000)\n",
    "clf.fit(X_train,Y_train)\n",
    "Y_Predicted=clf.predict(X_test)\n",
    "print(\"Accuracy:\",metrics.accuracy_score(Y_test, Y_Predicted)*100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. KNN classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 58.38150289017341 %\n"
     ]
    }
   ],
   "source": [
    "accuracies=[]\n",
    "for k in range(1,30):\n",
    "    clf=KNeighborsClassifier(n_neighbors = k)\n",
    "    clf.fit(X_train,Y_train)\n",
    "    Y_Predicted=clf.predict(X_test)\n",
    "    accuracies.append(metrics.accuracy_score(Y_test, Y_Predicted)*100)\n",
    "\n",
    "print(\"Accuracy:\",accuracies[np.argmax(accuracies)],\"%\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f3a52463084db90f96d29dcfcfd9bf276dba3c521d76c4c38c835392b64a093b"
  },
  "kernelspec": {
   "display_name": "Python 3.8.8 ('base')",
   "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.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}