main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0f4e00cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from skimage.io import imread\n",
    "from skimage.feature import hog,local_binary_pattern\n",
    "import glob\n",
    "import numpy as np\n",
    "from sklearn import svm\n",
    "from skimage import feature\n",
    "from sklearn.metrics import classification_report\n",
    "from skimage.color import rgb2gray\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e9d0fd13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import training live and spoof data\n",
    "live_train = glob.glob('data/train_live/live/*.png') #live\n",
    "spoof_train = glob.glob('data/train_spoof/spoof/*.png') #spoof\n",
    "\n",
    "# import testing live and spoof data\n",
    "live_test = glob.glob('data/test_live/live/*.png') #live\n",
    "spoof_test = glob.glob('data/test_spoof/spoof/*.png') #spoof"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "efa4daab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add all the images to lists\n",
    "live_train_images = []\n",
    "spoof_train_images = []\n",
    "live_test_images = []\n",
    "spoof_test_images = []\n",
    "\n",
    "# read images from given path using sklearn imread \n",
    "# and append to the above variales\n",
    "for path in live_train: live_train_images.append(imread(path))\n",
    "for path in spoof_train: spoof_train_images.append(imread(path))\n",
    "for path in live_test: live_test_images.append(imread(path))\n",
    "for path in spoof_test: spoof_test_images.append(imread(path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cc6e2b46",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convert the above data into numpy arrays\n",
    "# convert images to np arrays\n",
    "live_train_images, spoof_train_images = np.asarray(live_train_images), np.asarray(spoof_train_images)\n",
    "live_test_images, spoof_test_images = np.asarray(live_test_images), np.asarray(spoof_test_images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6e821010",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_features(feature_type=\"lbp\"):\n",
    "    # initialize empty lists to append features\n",
    "    live_train_features, spoof_train_features = [], []\n",
    "    live_test_features, spoof_test_features = [], []\n",
    "    \n",
    "    if(feature_type == \"hog\"):\n",
    "    \n",
    "        # calculate and store hog features of training data\n",
    "        for live_img, spoof_img in zip(live_train_images, spoof_train_images):\n",
    "            live_train_features.append(hog(live_img, feature_vector = True))\n",
    "            spoof_train_features.append(hog(spoof_img, feature_vector = True))\n",
    "\n",
    "        # calculate and store hog features of testing data\n",
    "        for live_img, spoof_img in zip(live_test_images, spoof_test_images):\n",
    "            live_test_features.append(hog(live_img, feature_vector = True))\n",
    "            spoof_test_features.append(hog(spoof_img, feature_vector = True))\n",
    "        \n",
    "    if(feature_type == \"lbp\"):\n",
    "\n",
    "        # parameters copied from scikit docs of lbp\n",
    "        METHOD = 'uniform'\n",
    "        R = 3\n",
    "        P = 8 * R\n",
    "\n",
    "        # calculate and store lbp features of training data\n",
    "        for live_img, spoof_img in zip(live_train_images, spoof_train_images):\n",
    "            live_img = rgb2gray(live_img)\n",
    "            spoof_img = rgb2gray(spoof_img)\n",
    "            live_train_features.append(local_binary_pattern(live_img, P, R, METHOD).flatten())\n",
    "            spoof_train_features.append(local_binary_pattern(spoof_img, P, R, METHOD).flatten())\n",
    "\n",
    "        # calculate and store lbp features of training data   \n",
    "        for live_img, spoof_img in zip(live_test_images, spoof_test_images):\n",
    "            # convert rgb to gray\n",
    "            live_img = rgb2gray(live_img)\n",
    "            # convert rgb to gray\n",
    "            spoof_img = rgb2gray(spoof_img)\n",
    "            live_test_features.append(local_binary_pattern(live_img, P, R, METHOD).flatten())\n",
    "            spoof_test_features.append(local_binary_pattern(spoof_img, P, R, METHOD).flatten())\n",
    "    \n",
    "    return live_train_features, spoof_train_features, live_test_features, spoof_test_features\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f28497d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Extract features using lbp first\n",
    "live_train_features, spoof_train_features, live_test_features, spoof_test_features = extract_features(feature_type=\"lbp\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "243fda6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define labels 1 for live and 0 for spoof\n",
    "labels_train = [[1]]*len(live_train_features) + [[0]]*len(spoof_train_features)\n",
    "\n",
    "# merge both positive and negative training data\n",
    "full_train = live_train_features + spoof_train_features\n",
    "\n",
    "# assign labels for all test data, 1 for positive, 0 for negative\n",
    "labels_test = [[1]]*len(live_test_features) + [[0]]*len(spoof_test_features)\n",
    "\n",
    "# merge both positive and negative training data\n",
    "full_test = live_test_features + spoof_test_features\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b25b87fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Scale the train and test data separetely to avoid leakage\n",
    "scaler = StandardScaler()\n",
    "X_test = scaler.fit_transform(full_test)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "66f8d141",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.37487347, -0.50505368, -0.03851738, ...,  2.27145538,\n",
       "        -0.64431606,  0.26904657],\n",
       "       [ 2.12428301,  0.47563308, -0.03851738, ..., -0.2888926 ,\n",
       "        -0.26474843,  0.26904657],\n",
       "       [ 2.12428301, -0.50505368, -0.03851738, ..., -0.2888926 ,\n",
       "        -0.13822588,  0.26904657],\n",
       "       ...,\n",
       "       [-0.79139955,  0.47563308, -0.03851738, ..., -0.2888926 ,\n",
       "         0.11481921,  0.26904657],\n",
       "       [-0.37487347,  0.47563308, -0.31864378, ..., -0.2888926 ,\n",
       "        -0.64431606,  0.26904657],\n",
       "       [-0.37487347,  0.47563308, -0.03851738, ..., -0.2888926 ,\n",
       "        -0.51779351,  0.26904657]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#define the SVC classifier\n",
    "clf = svm.SVC()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "048342f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fit the model with train set\n",
    "clf.fit(x_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84c60d00",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0897ee9d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c7ca45b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8878495",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "4d1c1056",
   "metadata": {},
   "outputs": [],
   "source": [
    "extract_features(feat=\"lbp\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7d9a0a4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8695a88",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b430311b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e21c9c57",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58dadff4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "159c9a44",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73d87b40",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}